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..2a2c112 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -6,8 +6,14 @@
 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
 )
 
 set(CMAKE_FOLDER "${CMAKE_FOLDER}/VulkanUtilityHeaders")
@@ -17,15 +23,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/utility/concurrent_unordered_map.hpp
+        vulkan/utility/vk_dispatch_table.h
+        vulkan/vk_enum_string_helper.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/concurrent_unordered_map.hpp b/include/vulkan/utility/concurrent_unordered_map.hpp
new file mode 100644
index 0000000..d00794c
--- /dev/null
+++ b/include/vulkan/utility/concurrent_unordered_map.hpp
@@ -0,0 +1,200 @@
+/* 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 <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..dbca78b
--- /dev/null
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -0,0 +1,18161 @@
+// *** 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 <cstdlib>
+#include <algorithm>
+#include <functional>
+
+namespace vku {
+namespace safe {
+
+// 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);
+
+struct BufferMemoryBarrier {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkBuffer buffer;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+
+    BufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BufferMemoryBarrier(const BufferMemoryBarrier& copy_src);
+    BufferMemoryBarrier& operator=(const BufferMemoryBarrier& copy_src);
+    BufferMemoryBarrier();
+    ~BufferMemoryBarrier();
+    void initialize(const VkBufferMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferMemoryBarrier* copy_src, PNextCopyState* copy_state = {});
+    VkBufferMemoryBarrier* ptr() { return reinterpret_cast<VkBufferMemoryBarrier*>(this); }
+    VkBufferMemoryBarrier const* ptr() const { return reinterpret_cast<VkBufferMemoryBarrier const*>(this); }
+};
+struct ImageMemoryBarrier {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+    VkImageLayout oldLayout;
+    VkImageLayout newLayout;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkImage image;
+    VkImageSubresourceRange subresourceRange;
+
+    ImageMemoryBarrier(const VkImageMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageMemoryBarrier(const ImageMemoryBarrier& copy_src);
+    ImageMemoryBarrier& operator=(const ImageMemoryBarrier& copy_src);
+    ImageMemoryBarrier();
+    ~ImageMemoryBarrier();
+    void initialize(const VkImageMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageMemoryBarrier* copy_src, PNextCopyState* copy_state = {});
+    VkImageMemoryBarrier* ptr() { return reinterpret_cast<VkImageMemoryBarrier*>(this); }
+    VkImageMemoryBarrier const* ptr() const { return reinterpret_cast<VkImageMemoryBarrier const*>(this); }
+};
+struct MemoryBarrier {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+
+    MemoryBarrier(const VkMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryBarrier(const MemoryBarrier& copy_src);
+    MemoryBarrier& operator=(const MemoryBarrier& copy_src);
+    MemoryBarrier();
+    ~MemoryBarrier();
+    void initialize(const VkMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryBarrier* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryBarrier* ptr() { return reinterpret_cast<VkMemoryBarrier*>(this); }
+    VkMemoryBarrier const* ptr() const { return reinterpret_cast<VkMemoryBarrier const*>(this); }
+};
+struct AllocationCallbacks {
+    void* pUserData{};
+    PFN_vkAllocationFunction pfnAllocation;
+    PFN_vkReallocationFunction pfnReallocation;
+    PFN_vkFreeFunction pfnFree;
+    PFN_vkInternalAllocationNotification pfnInternalAllocation;
+    PFN_vkInternalFreeNotification pfnInternalFree;
+
+    AllocationCallbacks(const VkAllocationCallbacks* in_struct, PNextCopyState* copy_state = {});
+    AllocationCallbacks(const AllocationCallbacks& copy_src);
+    AllocationCallbacks& operator=(const AllocationCallbacks& copy_src);
+    AllocationCallbacks();
+    ~AllocationCallbacks();
+    void initialize(const VkAllocationCallbacks* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AllocationCallbacks* copy_src, PNextCopyState* copy_state = {});
+    VkAllocationCallbacks* ptr() { return reinterpret_cast<VkAllocationCallbacks*>(this); }
+    VkAllocationCallbacks const* ptr() const { return reinterpret_cast<VkAllocationCallbacks const*>(this); }
+};
+struct ApplicationInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    const char* pApplicationName{};
+    uint32_t applicationVersion;
+    const char* pEngineName{};
+    uint32_t engineVersion;
+    uint32_t apiVersion;
+
+    ApplicationInfo(const VkApplicationInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ApplicationInfo(const ApplicationInfo& copy_src);
+    ApplicationInfo& operator=(const ApplicationInfo& copy_src);
+    ApplicationInfo();
+    ~ApplicationInfo();
+    void initialize(const VkApplicationInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ApplicationInfo* copy_src, PNextCopyState* copy_state = {});
+    VkApplicationInfo* ptr() { return reinterpret_cast<VkApplicationInfo*>(this); }
+    VkApplicationInfo const* ptr() const { return reinterpret_cast<VkApplicationInfo const*>(this); }
+};
+struct InstanceCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkInstanceCreateFlags flags;
+    ApplicationInfo* pApplicationInfo{};
+    uint32_t enabledLayerCount;
+    const char* const* ppEnabledLayerNames{};
+    uint32_t enabledExtensionCount;
+    const char* const* ppEnabledExtensionNames{};
+
+    InstanceCreateInfo(const VkInstanceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    InstanceCreateInfo(const InstanceCreateInfo& copy_src);
+    InstanceCreateInfo& operator=(const InstanceCreateInfo& copy_src);
+    InstanceCreateInfo();
+    ~InstanceCreateInfo();
+    void initialize(const VkInstanceCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const InstanceCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkInstanceCreateInfo* ptr() { return reinterpret_cast<VkInstanceCreateInfo*>(this); }
+    VkInstanceCreateInfo const* ptr() const { return reinterpret_cast<VkInstanceCreateInfo const*>(this); }
+};
+struct DeviceQueueCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceQueueCreateFlags flags;
+    uint32_t queueFamilyIndex;
+    uint32_t queueCount;
+    const float* pQueuePriorities{};
+
+    DeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DeviceQueueCreateInfo(const DeviceQueueCreateInfo& copy_src);
+    DeviceQueueCreateInfo& operator=(const DeviceQueueCreateInfo& copy_src);
+    DeviceQueueCreateInfo();
+    ~DeviceQueueCreateInfo();
+    void initialize(const VkDeviceQueueCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceQueueCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceQueueCreateInfo* ptr() { return reinterpret_cast<VkDeviceQueueCreateInfo*>(this); }
+    VkDeviceQueueCreateInfo const* ptr() const { return reinterpret_cast<VkDeviceQueueCreateInfo const*>(this); }
+};
+struct DeviceCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceCreateFlags flags;
+    uint32_t queueCreateInfoCount;
+    DeviceQueueCreateInfo* pQueueCreateInfos{};
+    uint32_t enabledLayerCount;
+    const char* const* ppEnabledLayerNames{};
+    uint32_t enabledExtensionCount;
+    const char* const* ppEnabledExtensionNames{};
+    const VkPhysicalDeviceFeatures* pEnabledFeatures{};
+
+    DeviceCreateInfo(const VkDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DeviceCreateInfo(const DeviceCreateInfo& copy_src);
+    DeviceCreateInfo& operator=(const DeviceCreateInfo& copy_src);
+    DeviceCreateInfo();
+    ~DeviceCreateInfo();
+    void initialize(const VkDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceCreateInfo* ptr() { return reinterpret_cast<VkDeviceCreateInfo*>(this); }
+    VkDeviceCreateInfo const* ptr() const { return reinterpret_cast<VkDeviceCreateInfo const*>(this); }
+};
+struct SubmitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t waitSemaphoreCount;
+    VkSemaphore* pWaitSemaphores{};
+    const VkPipelineStageFlags* pWaitDstStageMask{};
+    uint32_t commandBufferCount;
+    VkCommandBuffer* pCommandBuffers{};
+    uint32_t signalSemaphoreCount;
+    VkSemaphore* pSignalSemaphores{};
+
+    SubmitInfo(const VkSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SubmitInfo(const SubmitInfo& copy_src);
+    SubmitInfo& operator=(const SubmitInfo& copy_src);
+    SubmitInfo();
+    ~SubmitInfo();
+    void initialize(const VkSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSubmitInfo* ptr() { return reinterpret_cast<VkSubmitInfo*>(this); }
+    VkSubmitInfo const* ptr() const { return reinterpret_cast<VkSubmitInfo const*>(this); }
+};
+struct MappedMemoryRange {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+
+    MappedMemoryRange(const VkMappedMemoryRange* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MappedMemoryRange(const MappedMemoryRange& copy_src);
+    MappedMemoryRange& operator=(const MappedMemoryRange& copy_src);
+    MappedMemoryRange();
+    ~MappedMemoryRange();
+    void initialize(const VkMappedMemoryRange* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MappedMemoryRange* copy_src, PNextCopyState* copy_state = {});
+    VkMappedMemoryRange* ptr() { return reinterpret_cast<VkMappedMemoryRange*>(this); }
+    VkMappedMemoryRange const* ptr() const { return reinterpret_cast<VkMappedMemoryRange const*>(this); }
+};
+struct MemoryAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize allocationSize;
+    uint32_t memoryTypeIndex;
+
+    MemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryAllocateInfo(const MemoryAllocateInfo& copy_src);
+    MemoryAllocateInfo& operator=(const MemoryAllocateInfo& copy_src);
+    MemoryAllocateInfo();
+    ~MemoryAllocateInfo();
+    void initialize(const VkMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryAllocateInfo* ptr() { return reinterpret_cast<VkMemoryAllocateInfo*>(this); }
+    VkMemoryAllocateInfo const* ptr() const { return reinterpret_cast<VkMemoryAllocateInfo const*>(this); }
+};
+struct SparseBufferMemoryBindInfo {
+    VkBuffer buffer;
+    uint32_t bindCount;
+    VkSparseMemoryBind* pBinds{};
+
+    SparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    SparseBufferMemoryBindInfo(const SparseBufferMemoryBindInfo& copy_src);
+    SparseBufferMemoryBindInfo& operator=(const SparseBufferMemoryBindInfo& copy_src);
+    SparseBufferMemoryBindInfo();
+    ~SparseBufferMemoryBindInfo();
+    void initialize(const VkSparseBufferMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SparseBufferMemoryBindInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSparseBufferMemoryBindInfo* ptr() { return reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this); }
+    VkSparseBufferMemoryBindInfo const* ptr() const { return reinterpret_cast<VkSparseBufferMemoryBindInfo const*>(this); }
+};
+struct SparseImageOpaqueMemoryBindInfo {
+    VkImage image;
+    uint32_t bindCount;
+    VkSparseMemoryBind* pBinds{};
+
+    SparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    SparseImageOpaqueMemoryBindInfo(const SparseImageOpaqueMemoryBindInfo& copy_src);
+    SparseImageOpaqueMemoryBindInfo& operator=(const SparseImageOpaqueMemoryBindInfo& copy_src);
+    SparseImageOpaqueMemoryBindInfo();
+    ~SparseImageOpaqueMemoryBindInfo();
+    void initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SparseImageOpaqueMemoryBindInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSparseImageOpaqueMemoryBindInfo* ptr() { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this); }
+    VkSparseImageOpaqueMemoryBindInfo const* ptr() const {
+        return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo const*>(this);
+    }
+};
+struct SparseImageMemoryBindInfo {
+    VkImage image;
+    uint32_t bindCount;
+    VkSparseImageMemoryBind* pBinds{};
+
+    SparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    SparseImageMemoryBindInfo(const SparseImageMemoryBindInfo& copy_src);
+    SparseImageMemoryBindInfo& operator=(const SparseImageMemoryBindInfo& copy_src);
+    SparseImageMemoryBindInfo();
+    ~SparseImageMemoryBindInfo();
+    void initialize(const VkSparseImageMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SparseImageMemoryBindInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSparseImageMemoryBindInfo* ptr() { return reinterpret_cast<VkSparseImageMemoryBindInfo*>(this); }
+    VkSparseImageMemoryBindInfo const* ptr() const { return reinterpret_cast<VkSparseImageMemoryBindInfo const*>(this); }
+};
+struct BindSparseInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t waitSemaphoreCount;
+    VkSemaphore* pWaitSemaphores{};
+    uint32_t bufferBindCount;
+    SparseBufferMemoryBindInfo* pBufferBinds{};
+    uint32_t imageOpaqueBindCount;
+    SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds{};
+    uint32_t imageBindCount;
+    SparseImageMemoryBindInfo* pImageBinds{};
+    uint32_t signalSemaphoreCount;
+    VkSemaphore* pSignalSemaphores{};
+
+    BindSparseInfo(const VkBindSparseInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BindSparseInfo(const BindSparseInfo& copy_src);
+    BindSparseInfo& operator=(const BindSparseInfo& copy_src);
+    BindSparseInfo();
+    ~BindSparseInfo();
+    void initialize(const VkBindSparseInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindSparseInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindSparseInfo* ptr() { return reinterpret_cast<VkBindSparseInfo*>(this); }
+    VkBindSparseInfo const* ptr() const { return reinterpret_cast<VkBindSparseInfo const*>(this); }
+};
+struct FenceCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFenceCreateFlags flags;
+
+    FenceCreateInfo(const VkFenceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    FenceCreateInfo(const FenceCreateInfo& copy_src);
+    FenceCreateInfo& operator=(const FenceCreateInfo& copy_src);
+    FenceCreateInfo();
+    ~FenceCreateInfo();
+    void initialize(const VkFenceCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FenceCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkFenceCreateInfo* ptr() { return reinterpret_cast<VkFenceCreateInfo*>(this); }
+    VkFenceCreateInfo const* ptr() const { return reinterpret_cast<VkFenceCreateInfo const*>(this); }
+};
+struct SemaphoreCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphoreCreateFlags flags;
+
+    SemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SemaphoreCreateInfo(const SemaphoreCreateInfo& copy_src);
+    SemaphoreCreateInfo& operator=(const SemaphoreCreateInfo& copy_src);
+    SemaphoreCreateInfo();
+    ~SemaphoreCreateInfo();
+    void initialize(const VkSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SemaphoreCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreCreateInfo* ptr() { return reinterpret_cast<VkSemaphoreCreateInfo*>(this); }
+    VkSemaphoreCreateInfo const* ptr() const { return reinterpret_cast<VkSemaphoreCreateInfo const*>(this); }
+};
+struct EventCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkEventCreateFlags flags;
+
+    EventCreateInfo(const VkEventCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    EventCreateInfo(const EventCreateInfo& copy_src);
+    EventCreateInfo& operator=(const EventCreateInfo& copy_src);
+    EventCreateInfo();
+    ~EventCreateInfo();
+    void initialize(const VkEventCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const EventCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkEventCreateInfo* ptr() { return reinterpret_cast<VkEventCreateInfo*>(this); }
+    VkEventCreateInfo const* ptr() const { return reinterpret_cast<VkEventCreateInfo const*>(this); }
+};
+struct QueryPoolCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueryPoolCreateFlags flags;
+    VkQueryType queryType;
+    uint32_t queryCount;
+    VkQueryPipelineStatisticFlags pipelineStatistics;
+
+    QueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    QueryPoolCreateInfo(const QueryPoolCreateInfo& copy_src);
+    QueryPoolCreateInfo& operator=(const QueryPoolCreateInfo& copy_src);
+    QueryPoolCreateInfo();
+    ~QueryPoolCreateInfo();
+    void initialize(const VkQueryPoolCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const QueryPoolCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkQueryPoolCreateInfo* ptr() { return reinterpret_cast<VkQueryPoolCreateInfo*>(this); }
+    VkQueryPoolCreateInfo const* ptr() const { return reinterpret_cast<VkQueryPoolCreateInfo const*>(this); }
+};
+struct BufferCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferCreateFlags flags;
+    VkDeviceSize size;
+    VkBufferUsageFlags usage;
+    VkSharingMode sharingMode;
+    uint32_t queueFamilyIndexCount;
+    const uint32_t* pQueueFamilyIndices{};
+
+    BufferCreateInfo(const VkBufferCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BufferCreateInfo(const BufferCreateInfo& copy_src);
+    BufferCreateInfo& operator=(const BufferCreateInfo& copy_src);
+    BufferCreateInfo();
+    ~BufferCreateInfo();
+    void initialize(const VkBufferCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCreateInfo* ptr() { return reinterpret_cast<VkBufferCreateInfo*>(this); }
+    VkBufferCreateInfo const* ptr() const { return reinterpret_cast<VkBufferCreateInfo const*>(this); }
+};
+struct BufferViewCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferViewCreateFlags flags;
+    VkBuffer buffer;
+    VkFormat format;
+    VkDeviceSize offset;
+    VkDeviceSize range;
+
+    BufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BufferViewCreateInfo(const BufferViewCreateInfo& copy_src);
+    BufferViewCreateInfo& operator=(const BufferViewCreateInfo& copy_src);
+    BufferViewCreateInfo();
+    ~BufferViewCreateInfo();
+    void initialize(const VkBufferViewCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferViewCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBufferViewCreateInfo* ptr() { return reinterpret_cast<VkBufferViewCreateInfo*>(this); }
+    VkBufferViewCreateInfo const* ptr() const { return reinterpret_cast<VkBufferViewCreateInfo const*>(this); }
+};
+struct ImageCreateInfo {
+    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;
+
+    ImageCreateInfo(const VkImageCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageCreateInfo(const ImageCreateInfo& copy_src);
+    ImageCreateInfo& operator=(const ImageCreateInfo& copy_src);
+    ImageCreateInfo();
+    ~ImageCreateInfo();
+    void initialize(const VkImageCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImageCreateInfo* ptr() { return reinterpret_cast<VkImageCreateInfo*>(this); }
+    VkImageCreateInfo const* ptr() const { return reinterpret_cast<VkImageCreateInfo const*>(this); }
+};
+struct ImageViewCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageViewCreateFlags flags;
+    VkImage image;
+    VkImageViewType viewType;
+    VkFormat format;
+    VkComponentMapping components;
+    VkImageSubresourceRange subresourceRange;
+
+    ImageViewCreateInfo(const VkImageViewCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageViewCreateInfo(const ImageViewCreateInfo& copy_src);
+    ImageViewCreateInfo& operator=(const ImageViewCreateInfo& copy_src);
+    ImageViewCreateInfo();
+    ~ImageViewCreateInfo();
+    void initialize(const VkImageViewCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageViewCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewCreateInfo* ptr() { return reinterpret_cast<VkImageViewCreateInfo*>(this); }
+    VkImageViewCreateInfo const* ptr() const { return reinterpret_cast<VkImageViewCreateInfo const*>(this); }
+};
+struct ShaderModuleCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderModuleCreateFlags flags;
+    size_t codeSize;
+    const uint32_t* pCode{};
+
+    ShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ShaderModuleCreateInfo(const ShaderModuleCreateInfo& copy_src);
+    ShaderModuleCreateInfo& operator=(const ShaderModuleCreateInfo& copy_src);
+    ShaderModuleCreateInfo();
+    ~ShaderModuleCreateInfo();
+    void initialize(const VkShaderModuleCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ShaderModuleCreateInfo* 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 PipelineCacheCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCacheCreateFlags flags;
+    size_t initialDataSize;
+    const void* pInitialData{};
+
+    PipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineCacheCreateInfo(const PipelineCacheCreateInfo& copy_src);
+    PipelineCacheCreateInfo& operator=(const PipelineCacheCreateInfo& copy_src);
+    PipelineCacheCreateInfo();
+    ~PipelineCacheCreateInfo();
+    void initialize(const VkPipelineCacheCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineCacheCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCacheCreateInfo* ptr() { return reinterpret_cast<VkPipelineCacheCreateInfo*>(this); }
+    VkPipelineCacheCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineCacheCreateInfo const*>(this); }
+};
+struct SpecializationInfo {
+    uint32_t mapEntryCount;
+    const VkSpecializationMapEntry* pMapEntries{};
+    size_t dataSize;
+    const void* pData{};
+
+    SpecializationInfo(const VkSpecializationInfo* in_struct, PNextCopyState* copy_state = {});
+    SpecializationInfo(const SpecializationInfo& copy_src);
+    SpecializationInfo& operator=(const SpecializationInfo& copy_src);
+    SpecializationInfo();
+    ~SpecializationInfo();
+    void initialize(const VkSpecializationInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SpecializationInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSpecializationInfo* ptr() { return reinterpret_cast<VkSpecializationInfo*>(this); }
+    VkSpecializationInfo const* ptr() const { return reinterpret_cast<VkSpecializationInfo const*>(this); }
+};
+struct PipelineShaderStageCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineShaderStageCreateFlags flags;
+    VkShaderStageFlagBits stage;
+    VkShaderModule module;
+    const char* pName{};
+    SpecializationInfo* pSpecializationInfo{};
+
+    PipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    PipelineShaderStageCreateInfo(const PipelineShaderStageCreateInfo& copy_src);
+    PipelineShaderStageCreateInfo& operator=(const PipelineShaderStageCreateInfo& copy_src);
+    PipelineShaderStageCreateInfo();
+    ~PipelineShaderStageCreateInfo();
+    void initialize(const VkPipelineShaderStageCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineShaderStageCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineShaderStageCreateInfo* ptr() { return reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this); }
+    VkPipelineShaderStageCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineShaderStageCreateInfo const*>(this); }
+};
+struct ComputePipelineCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags flags;
+    PipelineShaderStageCreateInfo stage;
+    VkPipelineLayout layout;
+    VkPipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+
+    ComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    ComputePipelineCreateInfo(const ComputePipelineCreateInfo& copy_src);
+    ComputePipelineCreateInfo& operator=(const ComputePipelineCreateInfo& copy_src);
+    ComputePipelineCreateInfo();
+    ~ComputePipelineCreateInfo();
+    void initialize(const VkComputePipelineCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ComputePipelineCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkComputePipelineCreateInfo* ptr() { return reinterpret_cast<VkComputePipelineCreateInfo*>(this); }
+    VkComputePipelineCreateInfo const* ptr() const { return reinterpret_cast<VkComputePipelineCreateInfo const*>(this); }
+};
+struct PipelineVertexInputStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineVertexInputStateCreateFlags flags;
+    uint32_t vertexBindingDescriptionCount;
+    const VkVertexInputBindingDescription* pVertexBindingDescriptions{};
+    uint32_t vertexAttributeDescriptionCount;
+    const VkVertexInputAttributeDescription* pVertexAttributeDescriptions{};
+
+    PipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    PipelineVertexInputStateCreateInfo(const PipelineVertexInputStateCreateInfo& copy_src);
+    PipelineVertexInputStateCreateInfo& operator=(const PipelineVertexInputStateCreateInfo& copy_src);
+    PipelineVertexInputStateCreateInfo();
+    ~PipelineVertexInputStateCreateInfo();
+    void initialize(const VkPipelineVertexInputStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineVertexInputStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineVertexInputStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this); }
+    VkPipelineVertexInputStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineVertexInputStateCreateInfo const*>(this);
+    }
+};
+struct PipelineInputAssemblyStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineInputAssemblyStateCreateFlags flags;
+    VkPrimitiveTopology topology;
+    VkBool32 primitiveRestartEnable;
+
+    PipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PipelineInputAssemblyStateCreateInfo(const PipelineInputAssemblyStateCreateInfo& copy_src);
+    PipelineInputAssemblyStateCreateInfo& operator=(const PipelineInputAssemblyStateCreateInfo& copy_src);
+    PipelineInputAssemblyStateCreateInfo();
+    ~PipelineInputAssemblyStateCreateInfo();
+    void initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineInputAssemblyStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineInputAssemblyStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this); }
+    VkPipelineInputAssemblyStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo const*>(this);
+    }
+};
+struct PipelineTessellationStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineTessellationStateCreateFlags flags;
+    uint32_t patchControlPoints;
+
+    PipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    PipelineTessellationStateCreateInfo(const PipelineTessellationStateCreateInfo& copy_src);
+    PipelineTessellationStateCreateInfo& operator=(const PipelineTessellationStateCreateInfo& copy_src);
+    PipelineTessellationStateCreateInfo();
+    ~PipelineTessellationStateCreateInfo();
+    void initialize(const VkPipelineTessellationStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineTessellationStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineTessellationStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this); }
+    VkPipelineTessellationStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineTessellationStateCreateInfo const*>(this);
+    }
+};
+struct PipelineViewportStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineViewportStateCreateFlags flags;
+    uint32_t viewportCount;
+    const VkViewport* pViewports{};
+    uint32_t scissorCount;
+    const VkRect2D* pScissors{};
+
+    PipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports,
+                                    const bool is_dynamic_scissors, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineViewportStateCreateInfo(const PipelineViewportStateCreateInfo& copy_src);
+    PipelineViewportStateCreateInfo& operator=(const PipelineViewportStateCreateInfo& copy_src);
+    PipelineViewportStateCreateInfo();
+    ~PipelineViewportStateCreateInfo();
+    void initialize(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports,
+                    const bool is_dynamic_scissors, PNextCopyState* copy_state = {});
+    void initialize(const PipelineViewportStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this); }
+    VkPipelineViewportStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportStateCreateInfo const*>(this);
+    }
+};
+struct PipelineRasterizationStateCreateInfo {
+    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;
+
+    PipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PipelineRasterizationStateCreateInfo(const PipelineRasterizationStateCreateInfo& copy_src);
+    PipelineRasterizationStateCreateInfo& operator=(const PipelineRasterizationStateCreateInfo& copy_src);
+    PipelineRasterizationStateCreateInfo();
+    ~PipelineRasterizationStateCreateInfo();
+    void initialize(const VkPipelineRasterizationStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineRasterizationStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this); }
+    VkPipelineRasterizationStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationStateCreateInfo const*>(this);
+    }
+};
+struct PipelineMultisampleStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineMultisampleStateCreateFlags flags;
+    VkSampleCountFlagBits rasterizationSamples;
+    VkBool32 sampleShadingEnable;
+    float minSampleShading;
+    const VkSampleMask* pSampleMask{};
+    VkBool32 alphaToCoverageEnable;
+    VkBool32 alphaToOneEnable;
+
+    PipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    PipelineMultisampleStateCreateInfo(const PipelineMultisampleStateCreateInfo& copy_src);
+    PipelineMultisampleStateCreateInfo& operator=(const PipelineMultisampleStateCreateInfo& copy_src);
+    PipelineMultisampleStateCreateInfo();
+    ~PipelineMultisampleStateCreateInfo();
+    void initialize(const VkPipelineMultisampleStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineMultisampleStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineMultisampleStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this); }
+    VkPipelineMultisampleStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineMultisampleStateCreateInfo const*>(this);
+    }
+};
+struct PipelineDepthStencilStateCreateInfo {
+    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;
+
+    PipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    PipelineDepthStencilStateCreateInfo(const PipelineDepthStencilStateCreateInfo& copy_src);
+    PipelineDepthStencilStateCreateInfo& operator=(const PipelineDepthStencilStateCreateInfo& copy_src);
+    PipelineDepthStencilStateCreateInfo();
+    ~PipelineDepthStencilStateCreateInfo();
+    void initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineDepthStencilStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineDepthStencilStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this); }
+    VkPipelineDepthStencilStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo const*>(this);
+    }
+};
+struct PipelineColorBlendStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineColorBlendStateCreateFlags flags;
+    VkBool32 logicOpEnable;
+    VkLogicOp logicOp;
+    uint32_t attachmentCount;
+    const VkPipelineColorBlendAttachmentState* pAttachments{};
+    float blendConstants[4];
+
+    PipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    PipelineColorBlendStateCreateInfo(const PipelineColorBlendStateCreateInfo& copy_src);
+    PipelineColorBlendStateCreateInfo& operator=(const PipelineColorBlendStateCreateInfo& copy_src);
+    PipelineColorBlendStateCreateInfo();
+    ~PipelineColorBlendStateCreateInfo();
+    void initialize(const VkPipelineColorBlendStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineColorBlendStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineColorBlendStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this); }
+    VkPipelineColorBlendStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineColorBlendStateCreateInfo const*>(this);
+    }
+};
+struct PipelineDynamicStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineDynamicStateCreateFlags flags;
+    uint32_t dynamicStateCount;
+    const VkDynamicState* pDynamicStates{};
+
+    PipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    PipelineDynamicStateCreateInfo(const PipelineDynamicStateCreateInfo& copy_src);
+    PipelineDynamicStateCreateInfo& operator=(const PipelineDynamicStateCreateInfo& copy_src);
+    PipelineDynamicStateCreateInfo();
+    ~PipelineDynamicStateCreateInfo();
+    void initialize(const VkPipelineDynamicStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineDynamicStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineDynamicStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this); }
+    VkPipelineDynamicStateCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineDynamicStateCreateInfo const*>(this); }
+};
+struct GraphicsPipelineCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags flags;
+    uint32_t stageCount;
+    PipelineShaderStageCreateInfo* pStages{};
+    PipelineVertexInputStateCreateInfo* pVertexInputState{};
+    PipelineInputAssemblyStateCreateInfo* pInputAssemblyState{};
+    PipelineTessellationStateCreateInfo* pTessellationState{};
+    PipelineViewportStateCreateInfo* pViewportState{};
+    PipelineRasterizationStateCreateInfo* pRasterizationState{};
+    PipelineMultisampleStateCreateInfo* pMultisampleState{};
+    PipelineDepthStencilStateCreateInfo* pDepthStencilState{};
+    PipelineColorBlendStateCreateInfo* pColorBlendState{};
+    PipelineDynamicStateCreateInfo* pDynamicState{};
+    VkPipelineLayout layout;
+    VkRenderPass renderPass;
+    uint32_t subpass;
+    VkPipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+
+    GraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment,
+                               const bool uses_depthstencil_attachment, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    GraphicsPipelineCreateInfo(const GraphicsPipelineCreateInfo& copy_src);
+    GraphicsPipelineCreateInfo& operator=(const GraphicsPipelineCreateInfo& copy_src);
+    GraphicsPipelineCreateInfo();
+    ~GraphicsPipelineCreateInfo();
+    void initialize(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment,
+                    const bool uses_depthstencil_attachment, PNextCopyState* copy_state = {});
+    void initialize(const GraphicsPipelineCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkGraphicsPipelineCreateInfo* ptr() { return reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this); }
+    VkGraphicsPipelineCreateInfo const* ptr() const { return reinterpret_cast<VkGraphicsPipelineCreateInfo const*>(this); }
+};
+struct PipelineLayoutCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineLayoutCreateFlags flags;
+    uint32_t setLayoutCount;
+    VkDescriptorSetLayout* pSetLayouts{};
+    uint32_t pushConstantRangeCount;
+    const VkPushConstantRange* pPushConstantRanges{};
+
+    PipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineLayoutCreateInfo(const PipelineLayoutCreateInfo& copy_src);
+    PipelineLayoutCreateInfo& operator=(const PipelineLayoutCreateInfo& copy_src);
+    PipelineLayoutCreateInfo();
+    ~PipelineLayoutCreateInfo();
+    void initialize(const VkPipelineLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineLayoutCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineLayoutCreateInfo* ptr() { return reinterpret_cast<VkPipelineLayoutCreateInfo*>(this); }
+    VkPipelineLayoutCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineLayoutCreateInfo const*>(this); }
+};
+struct SamplerCreateInfo {
+    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;
+
+    SamplerCreateInfo(const VkSamplerCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SamplerCreateInfo(const SamplerCreateInfo& copy_src);
+    SamplerCreateInfo& operator=(const SamplerCreateInfo& copy_src);
+    SamplerCreateInfo();
+    ~SamplerCreateInfo();
+    void initialize(const VkSamplerCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SamplerCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerCreateInfo* ptr() { return reinterpret_cast<VkSamplerCreateInfo*>(this); }
+    VkSamplerCreateInfo const* ptr() const { return reinterpret_cast<VkSamplerCreateInfo const*>(this); }
+};
+struct CopyDescriptorSet {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorSet srcSet;
+    uint32_t srcBinding;
+    uint32_t srcArrayElement;
+    VkDescriptorSet dstSet;
+    uint32_t dstBinding;
+    uint32_t dstArrayElement;
+    uint32_t descriptorCount;
+
+    CopyDescriptorSet(const VkCopyDescriptorSet* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CopyDescriptorSet(const CopyDescriptorSet& copy_src);
+    CopyDescriptorSet& operator=(const CopyDescriptorSet& copy_src);
+    CopyDescriptorSet();
+    ~CopyDescriptorSet();
+    void initialize(const VkCopyDescriptorSet* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyDescriptorSet* copy_src, PNextCopyState* copy_state = {});
+    VkCopyDescriptorSet* ptr() { return reinterpret_cast<VkCopyDescriptorSet*>(this); }
+    VkCopyDescriptorSet const* ptr() const { return reinterpret_cast<VkCopyDescriptorSet const*>(this); }
+};
+struct DescriptorPoolCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorPoolCreateFlags flags;
+    uint32_t maxSets;
+    uint32_t poolSizeCount;
+    const VkDescriptorPoolSize* pPoolSizes{};
+
+    DescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DescriptorPoolCreateInfo(const DescriptorPoolCreateInfo& copy_src);
+    DescriptorPoolCreateInfo& operator=(const DescriptorPoolCreateInfo& copy_src);
+    DescriptorPoolCreateInfo();
+    ~DescriptorPoolCreateInfo();
+    void initialize(const VkDescriptorPoolCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorPoolCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorPoolCreateInfo* ptr() { return reinterpret_cast<VkDescriptorPoolCreateInfo*>(this); }
+    VkDescriptorPoolCreateInfo const* ptr() const { return reinterpret_cast<VkDescriptorPoolCreateInfo const*>(this); }
+};
+struct DescriptorSetAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorPool descriptorPool;
+    uint32_t descriptorSetCount;
+    VkDescriptorSetLayout* pSetLayouts{};
+
+    DescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    DescriptorSetAllocateInfo(const DescriptorSetAllocateInfo& copy_src);
+    DescriptorSetAllocateInfo& operator=(const DescriptorSetAllocateInfo& copy_src);
+    DescriptorSetAllocateInfo();
+    ~DescriptorSetAllocateInfo();
+    void initialize(const VkDescriptorSetAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorSetAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetAllocateInfo* ptr() { return reinterpret_cast<VkDescriptorSetAllocateInfo*>(this); }
+    VkDescriptorSetAllocateInfo const* ptr() const { return reinterpret_cast<VkDescriptorSetAllocateInfo const*>(this); }
+};
+struct DescriptorSetLayoutBinding {
+    uint32_t binding;
+    VkDescriptorType descriptorType;
+    uint32_t descriptorCount;
+    VkShaderStageFlags stageFlags;
+    VkSampler* pImmutableSamplers{};
+
+    DescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct, PNextCopyState* copy_state = {});
+    DescriptorSetLayoutBinding(const DescriptorSetLayoutBinding& copy_src);
+    DescriptorSetLayoutBinding& operator=(const DescriptorSetLayoutBinding& copy_src);
+    DescriptorSetLayoutBinding();
+    ~DescriptorSetLayoutBinding();
+    void initialize(const VkDescriptorSetLayoutBinding* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorSetLayoutBinding* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetLayoutBinding* ptr() { return reinterpret_cast<VkDescriptorSetLayoutBinding*>(this); }
+    VkDescriptorSetLayoutBinding const* ptr() const { return reinterpret_cast<VkDescriptorSetLayoutBinding const*>(this); }
+};
+struct DescriptorSetLayoutCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorSetLayoutCreateFlags flags;
+    uint32_t bindingCount;
+    DescriptorSetLayoutBinding* pBindings{};
+
+    DescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    DescriptorSetLayoutCreateInfo(const DescriptorSetLayoutCreateInfo& copy_src);
+    DescriptorSetLayoutCreateInfo& operator=(const DescriptorSetLayoutCreateInfo& copy_src);
+    DescriptorSetLayoutCreateInfo();
+    ~DescriptorSetLayoutCreateInfo();
+    void initialize(const VkDescriptorSetLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorSetLayoutCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetLayoutCreateInfo* ptr() { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this); }
+    VkDescriptorSetLayoutCreateInfo const* ptr() const { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo const*>(this); }
+};
+struct WriteDescriptorSet {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorSet dstSet;
+    uint32_t dstBinding;
+    uint32_t dstArrayElement;
+    uint32_t descriptorCount;
+    VkDescriptorType descriptorType;
+    VkDescriptorImageInfo* pImageInfo{};
+    VkDescriptorBufferInfo* pBufferInfo{};
+    VkBufferView* pTexelBufferView{};
+
+    WriteDescriptorSet(const VkWriteDescriptorSet* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    WriteDescriptorSet(const WriteDescriptorSet& copy_src);
+    WriteDescriptorSet& operator=(const WriteDescriptorSet& copy_src);
+    WriteDescriptorSet();
+    ~WriteDescriptorSet();
+    void initialize(const VkWriteDescriptorSet* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const WriteDescriptorSet* copy_src, PNextCopyState* copy_state = {});
+    VkWriteDescriptorSet* ptr() { return reinterpret_cast<VkWriteDescriptorSet*>(this); }
+    VkWriteDescriptorSet const* ptr() const { return reinterpret_cast<VkWriteDescriptorSet const*>(this); }
+};
+struct FramebufferCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFramebufferCreateFlags flags;
+    VkRenderPass renderPass;
+    uint32_t attachmentCount;
+    VkImageView* pAttachments{};
+    uint32_t width;
+    uint32_t height;
+    uint32_t layers;
+
+    FramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    FramebufferCreateInfo(const FramebufferCreateInfo& copy_src);
+    FramebufferCreateInfo& operator=(const FramebufferCreateInfo& copy_src);
+    FramebufferCreateInfo();
+    ~FramebufferCreateInfo();
+    void initialize(const VkFramebufferCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FramebufferCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkFramebufferCreateInfo* ptr() { return reinterpret_cast<VkFramebufferCreateInfo*>(this); }
+    VkFramebufferCreateInfo const* ptr() const { return reinterpret_cast<VkFramebufferCreateInfo const*>(this); }
+};
+struct SubpassDescription {
+    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{};
+
+    SubpassDescription(const VkSubpassDescription* in_struct, PNextCopyState* copy_state = {});
+    SubpassDescription(const SubpassDescription& copy_src);
+    SubpassDescription& operator=(const SubpassDescription& copy_src);
+    SubpassDescription();
+    ~SubpassDescription();
+    void initialize(const VkSubpassDescription* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubpassDescription* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassDescription* ptr() { return reinterpret_cast<VkSubpassDescription*>(this); }
+    VkSubpassDescription const* ptr() const { return reinterpret_cast<VkSubpassDescription const*>(this); }
+};
+struct RenderPassCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPassCreateFlags flags;
+    uint32_t attachmentCount;
+    const VkAttachmentDescription* pAttachments{};
+    uint32_t subpassCount;
+    SubpassDescription* pSubpasses{};
+    uint32_t dependencyCount;
+    const VkSubpassDependency* pDependencies{};
+
+    RenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderPassCreateInfo(const RenderPassCreateInfo& copy_src);
+    RenderPassCreateInfo& operator=(const RenderPassCreateInfo& copy_src);
+    RenderPassCreateInfo();
+    ~RenderPassCreateInfo();
+    void initialize(const VkRenderPassCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassCreateInfo* ptr() { return reinterpret_cast<VkRenderPassCreateInfo*>(this); }
+    VkRenderPassCreateInfo const* ptr() const { return reinterpret_cast<VkRenderPassCreateInfo const*>(this); }
+};
+struct CommandPoolCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCommandPoolCreateFlags flags;
+    uint32_t queueFamilyIndex;
+
+    CommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CommandPoolCreateInfo(const CommandPoolCreateInfo& copy_src);
+    CommandPoolCreateInfo& operator=(const CommandPoolCreateInfo& copy_src);
+    CommandPoolCreateInfo();
+    ~CommandPoolCreateInfo();
+    void initialize(const VkCommandPoolCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CommandPoolCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandPoolCreateInfo* ptr() { return reinterpret_cast<VkCommandPoolCreateInfo*>(this); }
+    VkCommandPoolCreateInfo const* ptr() const { return reinterpret_cast<VkCommandPoolCreateInfo const*>(this); }
+};
+struct CommandBufferAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCommandPool commandPool;
+    VkCommandBufferLevel level;
+    uint32_t commandBufferCount;
+
+    CommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    CommandBufferAllocateInfo(const CommandBufferAllocateInfo& copy_src);
+    CommandBufferAllocateInfo& operator=(const CommandBufferAllocateInfo& copy_src);
+    CommandBufferAllocateInfo();
+    ~CommandBufferAllocateInfo();
+    void initialize(const VkCommandBufferAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CommandBufferAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferAllocateInfo* ptr() { return reinterpret_cast<VkCommandBufferAllocateInfo*>(this); }
+    VkCommandBufferAllocateInfo const* ptr() const { return reinterpret_cast<VkCommandBufferAllocateInfo const*>(this); }
+};
+struct CommandBufferInheritanceInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPass renderPass;
+    uint32_t subpass;
+    VkFramebuffer framebuffer;
+    VkBool32 occlusionQueryEnable;
+    VkQueryControlFlags queryFlags;
+    VkQueryPipelineStatisticFlags pipelineStatistics;
+
+    CommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    CommandBufferInheritanceInfo(const CommandBufferInheritanceInfo& copy_src);
+    CommandBufferInheritanceInfo& operator=(const CommandBufferInheritanceInfo& copy_src);
+    CommandBufferInheritanceInfo();
+    ~CommandBufferInheritanceInfo();
+    void initialize(const VkCommandBufferInheritanceInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CommandBufferInheritanceInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferInheritanceInfo* ptr() { return reinterpret_cast<VkCommandBufferInheritanceInfo*>(this); }
+    VkCommandBufferInheritanceInfo const* ptr() const { return reinterpret_cast<VkCommandBufferInheritanceInfo const*>(this); }
+};
+struct CommandBufferBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCommandBufferUsageFlags flags;
+    CommandBufferInheritanceInfo* pInheritanceInfo{};
+
+    CommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CommandBufferBeginInfo(const CommandBufferBeginInfo& copy_src);
+    CommandBufferBeginInfo& operator=(const CommandBufferBeginInfo& copy_src);
+    CommandBufferBeginInfo();
+    ~CommandBufferBeginInfo();
+    void initialize(const VkCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CommandBufferBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferBeginInfo* ptr() { return reinterpret_cast<VkCommandBufferBeginInfo*>(this); }
+    VkCommandBufferBeginInfo const* ptr() const { return reinterpret_cast<VkCommandBufferBeginInfo const*>(this); }
+};
+struct RenderPassBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPass renderPass;
+    VkFramebuffer framebuffer;
+    VkRect2D renderArea;
+    uint32_t clearValueCount;
+    const VkClearValue* pClearValues{};
+
+    RenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderPassBeginInfo(const RenderPassBeginInfo& copy_src);
+    RenderPassBeginInfo& operator=(const RenderPassBeginInfo& copy_src);
+    RenderPassBeginInfo();
+    ~RenderPassBeginInfo();
+    void initialize(const VkRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassBeginInfo* ptr() { return reinterpret_cast<VkRenderPassBeginInfo*>(this); }
+    VkRenderPassBeginInfo const* ptr() const { return reinterpret_cast<VkRenderPassBeginInfo const*>(this); }
+};
+struct PhysicalDeviceSubgroupProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t subgroupSize;
+    VkShaderStageFlags supportedStages;
+    VkSubgroupFeatureFlags supportedOperations;
+    VkBool32 quadOperationsInAllStages;
+
+    PhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    PhysicalDeviceSubgroupProperties(const PhysicalDeviceSubgroupProperties& copy_src);
+    PhysicalDeviceSubgroupProperties& operator=(const PhysicalDeviceSubgroupProperties& copy_src);
+    PhysicalDeviceSubgroupProperties();
+    ~PhysicalDeviceSubgroupProperties();
+    void initialize(const VkPhysicalDeviceSubgroupProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSubgroupProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubgroupProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(this); }
+    VkPhysicalDeviceSubgroupProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubgroupProperties const*>(this);
+    }
+};
+struct BindBufferMemoryInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer buffer;
+    VkDeviceMemory memory;
+    VkDeviceSize memoryOffset;
+
+    BindBufferMemoryInfo(const VkBindBufferMemoryInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BindBufferMemoryInfo(const BindBufferMemoryInfo& copy_src);
+    BindBufferMemoryInfo& operator=(const BindBufferMemoryInfo& copy_src);
+    BindBufferMemoryInfo();
+    ~BindBufferMemoryInfo();
+    void initialize(const VkBindBufferMemoryInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindBufferMemoryInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindBufferMemoryInfo* ptr() { return reinterpret_cast<VkBindBufferMemoryInfo*>(this); }
+    VkBindBufferMemoryInfo const* ptr() const { return reinterpret_cast<VkBindBufferMemoryInfo const*>(this); }
+};
+struct BindImageMemoryInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    VkDeviceMemory memory;
+    VkDeviceSize memoryOffset;
+
+    BindImageMemoryInfo(const VkBindImageMemoryInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BindImageMemoryInfo(const BindImageMemoryInfo& copy_src);
+    BindImageMemoryInfo& operator=(const BindImageMemoryInfo& copy_src);
+    BindImageMemoryInfo();
+    ~BindImageMemoryInfo();
+    void initialize(const VkBindImageMemoryInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindImageMemoryInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindImageMemoryInfo* ptr() { return reinterpret_cast<VkBindImageMemoryInfo*>(this); }
+    VkBindImageMemoryInfo const* ptr() const { return reinterpret_cast<VkBindImageMemoryInfo const*>(this); }
+};
+struct PhysicalDevice16BitStorageFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 storageBuffer16BitAccess;
+    VkBool32 uniformAndStorageBuffer16BitAccess;
+    VkBool32 storagePushConstant16;
+    VkBool32 storageInputOutput16;
+
+    PhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    PhysicalDevice16BitStorageFeatures(const PhysicalDevice16BitStorageFeatures& copy_src);
+    PhysicalDevice16BitStorageFeatures& operator=(const PhysicalDevice16BitStorageFeatures& copy_src);
+    PhysicalDevice16BitStorageFeatures();
+    ~PhysicalDevice16BitStorageFeatures();
+    void initialize(const VkPhysicalDevice16BitStorageFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevice16BitStorageFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevice16BitStorageFeatures* ptr() { return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this); }
+    VkPhysicalDevice16BitStorageFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures const*>(this);
+    }
+};
+struct MemoryDedicatedRequirements {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 prefersDedicatedAllocation;
+    VkBool32 requiresDedicatedAllocation;
+
+    MemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    MemoryDedicatedRequirements(const MemoryDedicatedRequirements& copy_src);
+    MemoryDedicatedRequirements& operator=(const MemoryDedicatedRequirements& copy_src);
+    MemoryDedicatedRequirements();
+    ~MemoryDedicatedRequirements();
+    void initialize(const VkMemoryDedicatedRequirements* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryDedicatedRequirements* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryDedicatedRequirements* ptr() { return reinterpret_cast<VkMemoryDedicatedRequirements*>(this); }
+    VkMemoryDedicatedRequirements const* ptr() const { return reinterpret_cast<VkMemoryDedicatedRequirements const*>(this); }
+};
+struct MemoryDedicatedAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    VkBuffer buffer;
+
+    MemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    MemoryDedicatedAllocateInfo(const MemoryDedicatedAllocateInfo& copy_src);
+    MemoryDedicatedAllocateInfo& operator=(const MemoryDedicatedAllocateInfo& copy_src);
+    MemoryDedicatedAllocateInfo();
+    ~MemoryDedicatedAllocateInfo();
+    void initialize(const VkMemoryDedicatedAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryDedicatedAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryDedicatedAllocateInfo* ptr() { return reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this); }
+    VkMemoryDedicatedAllocateInfo const* ptr() const { return reinterpret_cast<VkMemoryDedicatedAllocateInfo const*>(this); }
+};
+struct MemoryAllocateFlagsInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMemoryAllocateFlags flags;
+    uint32_t deviceMask;
+
+    MemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryAllocateFlagsInfo(const MemoryAllocateFlagsInfo& copy_src);
+    MemoryAllocateFlagsInfo& operator=(const MemoryAllocateFlagsInfo& copy_src);
+    MemoryAllocateFlagsInfo();
+    ~MemoryAllocateFlagsInfo();
+    void initialize(const VkMemoryAllocateFlagsInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryAllocateFlagsInfo* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryAllocateFlagsInfo* ptr() { return reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this); }
+    VkMemoryAllocateFlagsInfo const* ptr() const { return reinterpret_cast<VkMemoryAllocateFlagsInfo const*>(this); }
+};
+struct DeviceGroupRenderPassBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t deviceMask;
+    uint32_t deviceRenderAreaCount;
+    const VkRect2D* pDeviceRenderAreas{};
+
+    DeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    DeviceGroupRenderPassBeginInfo(const DeviceGroupRenderPassBeginInfo& copy_src);
+    DeviceGroupRenderPassBeginInfo& operator=(const DeviceGroupRenderPassBeginInfo& copy_src);
+    DeviceGroupRenderPassBeginInfo();
+    ~DeviceGroupRenderPassBeginInfo();
+    void initialize(const VkDeviceGroupRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceGroupRenderPassBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupRenderPassBeginInfo* ptr() { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this); }
+    VkDeviceGroupRenderPassBeginInfo const* ptr() const { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo const*>(this); }
+};
+struct DeviceGroupCommandBufferBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t deviceMask;
+
+    DeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    DeviceGroupCommandBufferBeginInfo(const DeviceGroupCommandBufferBeginInfo& copy_src);
+    DeviceGroupCommandBufferBeginInfo& operator=(const DeviceGroupCommandBufferBeginInfo& copy_src);
+    DeviceGroupCommandBufferBeginInfo();
+    ~DeviceGroupCommandBufferBeginInfo();
+    void initialize(const VkDeviceGroupCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceGroupCommandBufferBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupCommandBufferBeginInfo* ptr() { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this); }
+    VkDeviceGroupCommandBufferBeginInfo const* ptr() const {
+        return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo const*>(this);
+    }
+};
+struct DeviceGroupSubmitInfo {
+    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{};
+
+    DeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DeviceGroupSubmitInfo(const DeviceGroupSubmitInfo& copy_src);
+    DeviceGroupSubmitInfo& operator=(const DeviceGroupSubmitInfo& copy_src);
+    DeviceGroupSubmitInfo();
+    ~DeviceGroupSubmitInfo();
+    void initialize(const VkDeviceGroupSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceGroupSubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupSubmitInfo* ptr() { return reinterpret_cast<VkDeviceGroupSubmitInfo*>(this); }
+    VkDeviceGroupSubmitInfo const* ptr() const { return reinterpret_cast<VkDeviceGroupSubmitInfo const*>(this); }
+};
+struct DeviceGroupBindSparseInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t resourceDeviceIndex;
+    uint32_t memoryDeviceIndex;
+
+    DeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    DeviceGroupBindSparseInfo(const DeviceGroupBindSparseInfo& copy_src);
+    DeviceGroupBindSparseInfo& operator=(const DeviceGroupBindSparseInfo& copy_src);
+    DeviceGroupBindSparseInfo();
+    ~DeviceGroupBindSparseInfo();
+    void initialize(const VkDeviceGroupBindSparseInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceGroupBindSparseInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupBindSparseInfo* ptr() { return reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this); }
+    VkDeviceGroupBindSparseInfo const* ptr() const { return reinterpret_cast<VkDeviceGroupBindSparseInfo const*>(this); }
+};
+struct BindBufferMemoryDeviceGroupInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t deviceIndexCount;
+    const uint32_t* pDeviceIndices{};
+
+    BindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    BindBufferMemoryDeviceGroupInfo(const BindBufferMemoryDeviceGroupInfo& copy_src);
+    BindBufferMemoryDeviceGroupInfo& operator=(const BindBufferMemoryDeviceGroupInfo& copy_src);
+    BindBufferMemoryDeviceGroupInfo();
+    ~BindBufferMemoryDeviceGroupInfo();
+    void initialize(const VkBindBufferMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindBufferMemoryDeviceGroupInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindBufferMemoryDeviceGroupInfo* ptr() { return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this); }
+    VkBindBufferMemoryDeviceGroupInfo const* ptr() const {
+        return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo const*>(this);
+    }
+};
+struct BindImageMemoryDeviceGroupInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t deviceIndexCount;
+    const uint32_t* pDeviceIndices{};
+    uint32_t splitInstanceBindRegionCount;
+    const VkRect2D* pSplitInstanceBindRegions{};
+
+    BindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    BindImageMemoryDeviceGroupInfo(const BindImageMemoryDeviceGroupInfo& copy_src);
+    BindImageMemoryDeviceGroupInfo& operator=(const BindImageMemoryDeviceGroupInfo& copy_src);
+    BindImageMemoryDeviceGroupInfo();
+    ~BindImageMemoryDeviceGroupInfo();
+    void initialize(const VkBindImageMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindImageMemoryDeviceGroupInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindImageMemoryDeviceGroupInfo* ptr() { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this); }
+    VkBindImageMemoryDeviceGroupInfo const* ptr() const { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo const*>(this); }
+};
+struct PhysicalDeviceGroupProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t physicalDeviceCount;
+    VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
+    VkBool32 subsetAllocation;
+
+    PhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    PhysicalDeviceGroupProperties(const PhysicalDeviceGroupProperties& copy_src);
+    PhysicalDeviceGroupProperties& operator=(const PhysicalDeviceGroupProperties& copy_src);
+    PhysicalDeviceGroupProperties();
+    ~PhysicalDeviceGroupProperties();
+    void initialize(const VkPhysicalDeviceGroupProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceGroupProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceGroupProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this); }
+    VkPhysicalDeviceGroupProperties const* ptr() const { return reinterpret_cast<VkPhysicalDeviceGroupProperties const*>(this); }
+};
+struct DeviceGroupDeviceCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t physicalDeviceCount;
+    VkPhysicalDevice* pPhysicalDevices{};
+
+    DeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    DeviceGroupDeviceCreateInfo(const DeviceGroupDeviceCreateInfo& copy_src);
+    DeviceGroupDeviceCreateInfo& operator=(const DeviceGroupDeviceCreateInfo& copy_src);
+    DeviceGroupDeviceCreateInfo();
+    ~DeviceGroupDeviceCreateInfo();
+    void initialize(const VkDeviceGroupDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceGroupDeviceCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupDeviceCreateInfo* ptr() { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this); }
+    VkDeviceGroupDeviceCreateInfo const* ptr() const { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo const*>(this); }
+};
+struct BufferMemoryRequirementsInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer buffer;
+
+    BufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    BufferMemoryRequirementsInfo2(const BufferMemoryRequirementsInfo2& copy_src);
+    BufferMemoryRequirementsInfo2& operator=(const BufferMemoryRequirementsInfo2& copy_src);
+    BufferMemoryRequirementsInfo2();
+    ~BufferMemoryRequirementsInfo2();
+    void initialize(const VkBufferMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferMemoryRequirementsInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkBufferMemoryRequirementsInfo2* ptr() { return reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this); }
+    VkBufferMemoryRequirementsInfo2 const* ptr() const { return reinterpret_cast<VkBufferMemoryRequirementsInfo2 const*>(this); }
+};
+struct ImageMemoryRequirementsInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+
+    ImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    ImageMemoryRequirementsInfo2(const ImageMemoryRequirementsInfo2& copy_src);
+    ImageMemoryRequirementsInfo2& operator=(const ImageMemoryRequirementsInfo2& copy_src);
+    ImageMemoryRequirementsInfo2();
+    ~ImageMemoryRequirementsInfo2();
+    void initialize(const VkImageMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageMemoryRequirementsInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkImageMemoryRequirementsInfo2* ptr() { return reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this); }
+    VkImageMemoryRequirementsInfo2 const* ptr() const { return reinterpret_cast<VkImageMemoryRequirementsInfo2 const*>(this); }
+};
+struct ImageSparseMemoryRequirementsInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+
+    ImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    ImageSparseMemoryRequirementsInfo2(const ImageSparseMemoryRequirementsInfo2& copy_src);
+    ImageSparseMemoryRequirementsInfo2& operator=(const ImageSparseMemoryRequirementsInfo2& copy_src);
+    ImageSparseMemoryRequirementsInfo2();
+    ~ImageSparseMemoryRequirementsInfo2();
+    void initialize(const VkImageSparseMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageSparseMemoryRequirementsInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkImageSparseMemoryRequirementsInfo2* ptr() { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this); }
+    VkImageSparseMemoryRequirementsInfo2 const* ptr() const {
+        return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 const*>(this);
+    }
+};
+struct MemoryRequirements2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkMemoryRequirements memoryRequirements;
+
+    MemoryRequirements2(const VkMemoryRequirements2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryRequirements2(const MemoryRequirements2& copy_src);
+    MemoryRequirements2& operator=(const MemoryRequirements2& copy_src);
+    MemoryRequirements2();
+    ~MemoryRequirements2();
+    void initialize(const VkMemoryRequirements2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryRequirements2* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryRequirements2* ptr() { return reinterpret_cast<VkMemoryRequirements2*>(this); }
+    VkMemoryRequirements2 const* ptr() const { return reinterpret_cast<VkMemoryRequirements2 const*>(this); }
+};
+struct SparseImageMemoryRequirements2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkSparseImageMemoryRequirements memoryRequirements;
+
+    SparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    SparseImageMemoryRequirements2(const SparseImageMemoryRequirements2& copy_src);
+    SparseImageMemoryRequirements2& operator=(const SparseImageMemoryRequirements2& copy_src);
+    SparseImageMemoryRequirements2();
+    ~SparseImageMemoryRequirements2();
+    void initialize(const VkSparseImageMemoryRequirements2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SparseImageMemoryRequirements2* copy_src, PNextCopyState* copy_state = {});
+    VkSparseImageMemoryRequirements2* ptr() { return reinterpret_cast<VkSparseImageMemoryRequirements2*>(this); }
+    VkSparseImageMemoryRequirements2 const* ptr() const { return reinterpret_cast<VkSparseImageMemoryRequirements2 const*>(this); }
+};
+struct PhysicalDeviceFeatures2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkPhysicalDeviceFeatures features;
+
+    PhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFeatures2(const PhysicalDeviceFeatures2& copy_src);
+    PhysicalDeviceFeatures2& operator=(const PhysicalDeviceFeatures2& copy_src);
+    PhysicalDeviceFeatures2();
+    ~PhysicalDeviceFeatures2();
+    void initialize(const VkPhysicalDeviceFeatures2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFeatures2* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFeatures2* ptr() { return reinterpret_cast<VkPhysicalDeviceFeatures2*>(this); }
+    VkPhysicalDeviceFeatures2 const* ptr() const { return reinterpret_cast<VkPhysicalDeviceFeatures2 const*>(this); }
+};
+struct PhysicalDeviceProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkPhysicalDeviceProperties properties;
+
+    PhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    PhysicalDeviceProperties2(const PhysicalDeviceProperties2& copy_src);
+    PhysicalDeviceProperties2& operator=(const PhysicalDeviceProperties2& copy_src);
+    PhysicalDeviceProperties2();
+    ~PhysicalDeviceProperties2();
+    void initialize(const VkPhysicalDeviceProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceProperties2* ptr() { return reinterpret_cast<VkPhysicalDeviceProperties2*>(this); }
+    VkPhysicalDeviceProperties2 const* ptr() const { return reinterpret_cast<VkPhysicalDeviceProperties2 const*>(this); }
+};
+struct FormatProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormatProperties formatProperties;
+
+    FormatProperties2(const VkFormatProperties2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    FormatProperties2(const FormatProperties2& copy_src);
+    FormatProperties2& operator=(const FormatProperties2& copy_src);
+    FormatProperties2();
+    ~FormatProperties2();
+    void initialize(const VkFormatProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FormatProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkFormatProperties2* ptr() { return reinterpret_cast<VkFormatProperties2*>(this); }
+    VkFormatProperties2 const* ptr() const { return reinterpret_cast<VkFormatProperties2 const*>(this); }
+};
+struct ImageFormatProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageFormatProperties imageFormatProperties;
+
+    ImageFormatProperties2(const VkImageFormatProperties2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageFormatProperties2(const ImageFormatProperties2& copy_src);
+    ImageFormatProperties2& operator=(const ImageFormatProperties2& copy_src);
+    ImageFormatProperties2();
+    ~ImageFormatProperties2();
+    void initialize(const VkImageFormatProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageFormatProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkImageFormatProperties2* ptr() { return reinterpret_cast<VkImageFormatProperties2*>(this); }
+    VkImageFormatProperties2 const* ptr() const { return reinterpret_cast<VkImageFormatProperties2 const*>(this); }
+};
+struct PhysicalDeviceImageFormatInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat format;
+    VkImageType type;
+    VkImageTiling tiling;
+    VkImageUsageFlags usage;
+    VkImageCreateFlags flags;
+
+    PhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    PhysicalDeviceImageFormatInfo2(const PhysicalDeviceImageFormatInfo2& copy_src);
+    PhysicalDeviceImageFormatInfo2& operator=(const PhysicalDeviceImageFormatInfo2& copy_src);
+    PhysicalDeviceImageFormatInfo2();
+    ~PhysicalDeviceImageFormatInfo2();
+    void initialize(const VkPhysicalDeviceImageFormatInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageFormatInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageFormatInfo2* ptr() { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this); }
+    VkPhysicalDeviceImageFormatInfo2 const* ptr() const { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 const*>(this); }
+};
+struct QueueFamilyProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkQueueFamilyProperties queueFamilyProperties;
+
+    QueueFamilyProperties2(const VkQueueFamilyProperties2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    QueueFamilyProperties2(const QueueFamilyProperties2& copy_src);
+    QueueFamilyProperties2& operator=(const QueueFamilyProperties2& copy_src);
+    QueueFamilyProperties2();
+    ~QueueFamilyProperties2();
+    void initialize(const VkQueueFamilyProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const QueueFamilyProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyProperties2* ptr() { return reinterpret_cast<VkQueueFamilyProperties2*>(this); }
+    VkQueueFamilyProperties2 const* ptr() const { return reinterpret_cast<VkQueueFamilyProperties2 const*>(this); }
+};
+struct PhysicalDeviceMemoryProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkPhysicalDeviceMemoryProperties memoryProperties;
+
+    PhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    PhysicalDeviceMemoryProperties2(const PhysicalDeviceMemoryProperties2& copy_src);
+    PhysicalDeviceMemoryProperties2& operator=(const PhysicalDeviceMemoryProperties2& copy_src);
+    PhysicalDeviceMemoryProperties2();
+    ~PhysicalDeviceMemoryProperties2();
+    void initialize(const VkPhysicalDeviceMemoryProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMemoryProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMemoryProperties2* ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this); }
+    VkPhysicalDeviceMemoryProperties2 const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMemoryProperties2 const*>(this);
+    }
+};
+struct SparseImageFormatProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkSparseImageFormatProperties properties;
+
+    SparseImageFormatProperties2(const VkSparseImageFormatProperties2* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    SparseImageFormatProperties2(const SparseImageFormatProperties2& copy_src);
+    SparseImageFormatProperties2& operator=(const SparseImageFormatProperties2& copy_src);
+    SparseImageFormatProperties2();
+    ~SparseImageFormatProperties2();
+    void initialize(const VkSparseImageFormatProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SparseImageFormatProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkSparseImageFormatProperties2* ptr() { return reinterpret_cast<VkSparseImageFormatProperties2*>(this); }
+    VkSparseImageFormatProperties2 const* ptr() const { return reinterpret_cast<VkSparseImageFormatProperties2 const*>(this); }
+};
+struct PhysicalDeviceSparseImageFormatInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat format;
+    VkImageType type;
+    VkSampleCountFlagBits samples;
+    VkImageUsageFlags usage;
+    VkImageTiling tiling;
+
+    PhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDeviceSparseImageFormatInfo2(const PhysicalDeviceSparseImageFormatInfo2& copy_src);
+    PhysicalDeviceSparseImageFormatInfo2& operator=(const PhysicalDeviceSparseImageFormatInfo2& copy_src);
+    PhysicalDeviceSparseImageFormatInfo2();
+    ~PhysicalDeviceSparseImageFormatInfo2();
+    void initialize(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSparseImageFormatInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSparseImageFormatInfo2* ptr() { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this); }
+    VkPhysicalDeviceSparseImageFormatInfo2 const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 const*>(this);
+    }
+};
+struct PhysicalDevicePointClippingProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkPointClippingBehavior pointClippingBehavior;
+
+    PhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDevicePointClippingProperties(const PhysicalDevicePointClippingProperties& copy_src);
+    PhysicalDevicePointClippingProperties& operator=(const PhysicalDevicePointClippingProperties& copy_src);
+    PhysicalDevicePointClippingProperties();
+    ~PhysicalDevicePointClippingProperties();
+    void initialize(const VkPhysicalDevicePointClippingProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePointClippingProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePointClippingProperties* ptr() { return reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(this); }
+    VkPhysicalDevicePointClippingProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePointClippingProperties const*>(this);
+    }
+};
+struct RenderPassInputAttachmentAspectCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t aspectReferenceCount;
+    const VkInputAttachmentAspectReference* pAspectReferences{};
+
+    RenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderPassInputAttachmentAspectCreateInfo(const RenderPassInputAttachmentAspectCreateInfo& copy_src);
+    RenderPassInputAttachmentAspectCreateInfo& operator=(const RenderPassInputAttachmentAspectCreateInfo& copy_src);
+    RenderPassInputAttachmentAspectCreateInfo();
+    ~RenderPassInputAttachmentAspectCreateInfo();
+    void initialize(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassInputAttachmentAspectCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassInputAttachmentAspectCreateInfo* ptr() {
+        return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this);
+    }
+    VkRenderPassInputAttachmentAspectCreateInfo const* ptr() const {
+        return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo const*>(this);
+    }
+};
+struct ImageViewUsageCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageUsageFlags usage;
+
+    ImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageViewUsageCreateInfo(const ImageViewUsageCreateInfo& copy_src);
+    ImageViewUsageCreateInfo& operator=(const ImageViewUsageCreateInfo& copy_src);
+    ImageViewUsageCreateInfo();
+    ~ImageViewUsageCreateInfo();
+    void initialize(const VkImageViewUsageCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageViewUsageCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewUsageCreateInfo* ptr() { return reinterpret_cast<VkImageViewUsageCreateInfo*>(this); }
+    VkImageViewUsageCreateInfo const* ptr() const { return reinterpret_cast<VkImageViewUsageCreateInfo const*>(this); }
+};
+struct PipelineTessellationDomainOriginStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTessellationDomainOrigin domainOrigin;
+
+    PipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineTessellationDomainOriginStateCreateInfo(const PipelineTessellationDomainOriginStateCreateInfo& copy_src);
+    PipelineTessellationDomainOriginStateCreateInfo& operator=(const PipelineTessellationDomainOriginStateCreateInfo& copy_src);
+    PipelineTessellationDomainOriginStateCreateInfo();
+    ~PipelineTessellationDomainOriginStateCreateInfo();
+    void initialize(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineTessellationDomainOriginStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineTessellationDomainOriginStateCreateInfo* ptr() {
+        return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this);
+    }
+    VkPipelineTessellationDomainOriginStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo const*>(this);
+    }
+};
+struct RenderPassMultiviewCreateInfo {
+    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{};
+
+    RenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    RenderPassMultiviewCreateInfo(const RenderPassMultiviewCreateInfo& copy_src);
+    RenderPassMultiviewCreateInfo& operator=(const RenderPassMultiviewCreateInfo& copy_src);
+    RenderPassMultiviewCreateInfo();
+    ~RenderPassMultiviewCreateInfo();
+    void initialize(const VkRenderPassMultiviewCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassMultiviewCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassMultiviewCreateInfo* ptr() { return reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this); }
+    VkRenderPassMultiviewCreateInfo const* ptr() const { return reinterpret_cast<VkRenderPassMultiviewCreateInfo const*>(this); }
+};
+struct PhysicalDeviceMultiviewFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 multiview;
+    VkBool32 multiviewGeometryShader;
+    VkBool32 multiviewTessellationShader;
+
+    PhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    PhysicalDeviceMultiviewFeatures(const PhysicalDeviceMultiviewFeatures& copy_src);
+    PhysicalDeviceMultiviewFeatures& operator=(const PhysicalDeviceMultiviewFeatures& copy_src);
+    PhysicalDeviceMultiviewFeatures();
+    ~PhysicalDeviceMultiviewFeatures();
+    void initialize(const VkPhysicalDeviceMultiviewFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMultiviewFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiviewFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this); }
+    VkPhysicalDeviceMultiviewFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceMultiviewProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxMultiviewViewCount;
+    uint32_t maxMultiviewInstanceIndex;
+
+    PhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    PhysicalDeviceMultiviewProperties(const PhysicalDeviceMultiviewProperties& copy_src);
+    PhysicalDeviceMultiviewProperties& operator=(const PhysicalDeviceMultiviewProperties& copy_src);
+    PhysicalDeviceMultiviewProperties();
+    ~PhysicalDeviceMultiviewProperties();
+    void initialize(const VkPhysicalDeviceMultiviewProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMultiviewProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiviewProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(this); }
+    VkPhysicalDeviceMultiviewProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewProperties const*>(this);
+    }
+};
+struct PhysicalDeviceVariablePointersFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 variablePointersStorageBuffer;
+    VkBool32 variablePointers;
+
+    PhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceVariablePointersFeatures(const PhysicalDeviceVariablePointersFeatures& copy_src);
+    PhysicalDeviceVariablePointersFeatures& operator=(const PhysicalDeviceVariablePointersFeatures& copy_src);
+    PhysicalDeviceVariablePointersFeatures();
+    ~PhysicalDeviceVariablePointersFeatures();
+    void initialize(const VkPhysicalDeviceVariablePointersFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVariablePointersFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVariablePointersFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(this); }
+    VkPhysicalDeviceVariablePointersFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceProtectedMemoryFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 protectedMemory;
+
+    PhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDeviceProtectedMemoryFeatures(const PhysicalDeviceProtectedMemoryFeatures& copy_src);
+    PhysicalDeviceProtectedMemoryFeatures& operator=(const PhysicalDeviceProtectedMemoryFeatures& copy_src);
+    PhysicalDeviceProtectedMemoryFeatures();
+    ~PhysicalDeviceProtectedMemoryFeatures();
+    void initialize(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceProtectedMemoryFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceProtectedMemoryFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this); }
+    VkPhysicalDeviceProtectedMemoryFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceProtectedMemoryProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 protectedNoFault;
+
+    PhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceProtectedMemoryProperties(const PhysicalDeviceProtectedMemoryProperties& copy_src);
+    PhysicalDeviceProtectedMemoryProperties& operator=(const PhysicalDeviceProtectedMemoryProperties& copy_src);
+    PhysicalDeviceProtectedMemoryProperties();
+    ~PhysicalDeviceProtectedMemoryProperties();
+    void initialize(const VkPhysicalDeviceProtectedMemoryProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceProtectedMemoryProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceProtectedMemoryProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this); }
+    VkPhysicalDeviceProtectedMemoryProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties const*>(this);
+    }
+};
+struct DeviceQueueInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceQueueCreateFlags flags;
+    uint32_t queueFamilyIndex;
+    uint32_t queueIndex;
+
+    DeviceQueueInfo2(const VkDeviceQueueInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DeviceQueueInfo2(const DeviceQueueInfo2& copy_src);
+    DeviceQueueInfo2& operator=(const DeviceQueueInfo2& copy_src);
+    DeviceQueueInfo2();
+    ~DeviceQueueInfo2();
+    void initialize(const VkDeviceQueueInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceQueueInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceQueueInfo2* ptr() { return reinterpret_cast<VkDeviceQueueInfo2*>(this); }
+    VkDeviceQueueInfo2 const* ptr() const { return reinterpret_cast<VkDeviceQueueInfo2 const*>(this); }
+};
+struct ProtectedSubmitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 protectedSubmit;
+
+    ProtectedSubmitInfo(const VkProtectedSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ProtectedSubmitInfo(const ProtectedSubmitInfo& copy_src);
+    ProtectedSubmitInfo& operator=(const ProtectedSubmitInfo& copy_src);
+    ProtectedSubmitInfo();
+    ~ProtectedSubmitInfo();
+    void initialize(const VkProtectedSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ProtectedSubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkProtectedSubmitInfo* ptr() { return reinterpret_cast<VkProtectedSubmitInfo*>(this); }
+    VkProtectedSubmitInfo const* ptr() const { return reinterpret_cast<VkProtectedSubmitInfo const*>(this); }
+};
+struct SamplerYcbcrConversionCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat format;
+    VkSamplerYcbcrModelConversion ycbcrModel;
+    VkSamplerYcbcrRange ycbcrRange;
+    VkComponentMapping components;
+    VkChromaLocation xChromaOffset;
+    VkChromaLocation yChromaOffset;
+    VkFilter chromaFilter;
+    VkBool32 forceExplicitReconstruction;
+
+    SamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    SamplerYcbcrConversionCreateInfo(const SamplerYcbcrConversionCreateInfo& copy_src);
+    SamplerYcbcrConversionCreateInfo& operator=(const SamplerYcbcrConversionCreateInfo& copy_src);
+    SamplerYcbcrConversionCreateInfo();
+    ~SamplerYcbcrConversionCreateInfo();
+    void initialize(const VkSamplerYcbcrConversionCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SamplerYcbcrConversionCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerYcbcrConversionCreateInfo* ptr() { return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this); }
+    VkSamplerYcbcrConversionCreateInfo const* ptr() const {
+        return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo const*>(this);
+    }
+};
+struct SamplerYcbcrConversionInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSamplerYcbcrConversion conversion;
+
+    SamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    SamplerYcbcrConversionInfo(const SamplerYcbcrConversionInfo& copy_src);
+    SamplerYcbcrConversionInfo& operator=(const SamplerYcbcrConversionInfo& copy_src);
+    SamplerYcbcrConversionInfo();
+    ~SamplerYcbcrConversionInfo();
+    void initialize(const VkSamplerYcbcrConversionInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SamplerYcbcrConversionInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerYcbcrConversionInfo* ptr() { return reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this); }
+    VkSamplerYcbcrConversionInfo const* ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionInfo const*>(this); }
+};
+struct BindImagePlaneMemoryInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageAspectFlagBits planeAspect;
+
+    BindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BindImagePlaneMemoryInfo(const BindImagePlaneMemoryInfo& copy_src);
+    BindImagePlaneMemoryInfo& operator=(const BindImagePlaneMemoryInfo& copy_src);
+    BindImagePlaneMemoryInfo();
+    ~BindImagePlaneMemoryInfo();
+    void initialize(const VkBindImagePlaneMemoryInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindImagePlaneMemoryInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindImagePlaneMemoryInfo* ptr() { return reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this); }
+    VkBindImagePlaneMemoryInfo const* ptr() const { return reinterpret_cast<VkBindImagePlaneMemoryInfo const*>(this); }
+};
+struct ImagePlaneMemoryRequirementsInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageAspectFlagBits planeAspect;
+
+    ImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    ImagePlaneMemoryRequirementsInfo(const ImagePlaneMemoryRequirementsInfo& copy_src);
+    ImagePlaneMemoryRequirementsInfo& operator=(const ImagePlaneMemoryRequirementsInfo& copy_src);
+    ImagePlaneMemoryRequirementsInfo();
+    ~ImagePlaneMemoryRequirementsInfo();
+    void initialize(const VkImagePlaneMemoryRequirementsInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImagePlaneMemoryRequirementsInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImagePlaneMemoryRequirementsInfo* ptr() { return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this); }
+    VkImagePlaneMemoryRequirementsInfo const* ptr() const {
+        return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo const*>(this);
+    }
+};
+struct PhysicalDeviceSamplerYcbcrConversionFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 samplerYcbcrConversion;
+
+    PhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSamplerYcbcrConversionFeatures(const PhysicalDeviceSamplerYcbcrConversionFeatures& copy_src);
+    PhysicalDeviceSamplerYcbcrConversionFeatures& operator=(const PhysicalDeviceSamplerYcbcrConversionFeatures& copy_src);
+    PhysicalDeviceSamplerYcbcrConversionFeatures();
+    ~PhysicalDeviceSamplerYcbcrConversionFeatures();
+    void initialize(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSamplerYcbcrConversionFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this);
+    }
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures const*>(this);
+    }
+};
+struct SamplerYcbcrConversionImageFormatProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t combinedImageSamplerDescriptorCount;
+
+    SamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SamplerYcbcrConversionImageFormatProperties(const SamplerYcbcrConversionImageFormatProperties& copy_src);
+    SamplerYcbcrConversionImageFormatProperties& operator=(const SamplerYcbcrConversionImageFormatProperties& copy_src);
+    SamplerYcbcrConversionImageFormatProperties();
+    ~SamplerYcbcrConversionImageFormatProperties();
+    void initialize(const VkSamplerYcbcrConversionImageFormatProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SamplerYcbcrConversionImageFormatProperties* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerYcbcrConversionImageFormatProperties* ptr() {
+        return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(this);
+    }
+    VkSamplerYcbcrConversionImageFormatProperties const* ptr() const {
+        return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties const*>(this);
+    }
+};
+struct DescriptorUpdateTemplateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorUpdateTemplateCreateFlags flags;
+    uint32_t descriptorUpdateEntryCount;
+    const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries{};
+    VkDescriptorUpdateTemplateType templateType;
+    VkDescriptorSetLayout descriptorSetLayout;
+    VkPipelineBindPoint pipelineBindPoint;
+    VkPipelineLayout pipelineLayout;
+    uint32_t set;
+
+    DescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    DescriptorUpdateTemplateCreateInfo(const DescriptorUpdateTemplateCreateInfo& copy_src);
+    DescriptorUpdateTemplateCreateInfo& operator=(const DescriptorUpdateTemplateCreateInfo& copy_src);
+    DescriptorUpdateTemplateCreateInfo();
+    ~DescriptorUpdateTemplateCreateInfo();
+    void initialize(const VkDescriptorUpdateTemplateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorUpdateTemplateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorUpdateTemplateCreateInfo* ptr() { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this); }
+    VkDescriptorUpdateTemplateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo const*>(this);
+    }
+};
+struct PhysicalDeviceExternalImageFormatInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    PhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDeviceExternalImageFormatInfo(const PhysicalDeviceExternalImageFormatInfo& copy_src);
+    PhysicalDeviceExternalImageFormatInfo& operator=(const PhysicalDeviceExternalImageFormatInfo& copy_src);
+    PhysicalDeviceExternalImageFormatInfo();
+    ~PhysicalDeviceExternalImageFormatInfo();
+    void initialize(const VkPhysicalDeviceExternalImageFormatInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExternalImageFormatInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalImageFormatInfo* ptr() { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this); }
+    VkPhysicalDeviceExternalImageFormatInfo const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo const*>(this);
+    }
+};
+struct ExternalImageFormatProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkExternalMemoryProperties externalMemoryProperties;
+
+    ExternalImageFormatProperties(const VkExternalImageFormatProperties* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    ExternalImageFormatProperties(const ExternalImageFormatProperties& copy_src);
+    ExternalImageFormatProperties& operator=(const ExternalImageFormatProperties& copy_src);
+    ExternalImageFormatProperties();
+    ~ExternalImageFormatProperties();
+    void initialize(const VkExternalImageFormatProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExternalImageFormatProperties* copy_src, PNextCopyState* copy_state = {});
+    VkExternalImageFormatProperties* ptr() { return reinterpret_cast<VkExternalImageFormatProperties*>(this); }
+    VkExternalImageFormatProperties const* ptr() const { return reinterpret_cast<VkExternalImageFormatProperties const*>(this); }
+};
+struct PhysicalDeviceExternalBufferInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferCreateFlags flags;
+    VkBufferUsageFlags usage;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    PhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    PhysicalDeviceExternalBufferInfo(const PhysicalDeviceExternalBufferInfo& copy_src);
+    PhysicalDeviceExternalBufferInfo& operator=(const PhysicalDeviceExternalBufferInfo& copy_src);
+    PhysicalDeviceExternalBufferInfo();
+    ~PhysicalDeviceExternalBufferInfo();
+    void initialize(const VkPhysicalDeviceExternalBufferInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExternalBufferInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalBufferInfo* ptr() { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this); }
+    VkPhysicalDeviceExternalBufferInfo const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo const*>(this);
+    }
+};
+struct ExternalBufferProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkExternalMemoryProperties externalMemoryProperties;
+
+    ExternalBufferProperties(const VkExternalBufferProperties* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ExternalBufferProperties(const ExternalBufferProperties& copy_src);
+    ExternalBufferProperties& operator=(const ExternalBufferProperties& copy_src);
+    ExternalBufferProperties();
+    ~ExternalBufferProperties();
+    void initialize(const VkExternalBufferProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExternalBufferProperties* copy_src, PNextCopyState* copy_state = {});
+    VkExternalBufferProperties* ptr() { return reinterpret_cast<VkExternalBufferProperties*>(this); }
+    VkExternalBufferProperties const* ptr() const { return reinterpret_cast<VkExternalBufferProperties const*>(this); }
+};
+struct PhysicalDeviceIDProperties {
+    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;
+
+    PhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    PhysicalDeviceIDProperties(const PhysicalDeviceIDProperties& copy_src);
+    PhysicalDeviceIDProperties& operator=(const PhysicalDeviceIDProperties& copy_src);
+    PhysicalDeviceIDProperties();
+    ~PhysicalDeviceIDProperties();
+    void initialize(const VkPhysicalDeviceIDProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceIDProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceIDProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceIDProperties*>(this); }
+    VkPhysicalDeviceIDProperties const* ptr() const { return reinterpret_cast<VkPhysicalDeviceIDProperties const*>(this); }
+};
+struct ExternalMemoryImageCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlags handleTypes;
+
+    ExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    ExternalMemoryImageCreateInfo(const ExternalMemoryImageCreateInfo& copy_src);
+    ExternalMemoryImageCreateInfo& operator=(const ExternalMemoryImageCreateInfo& copy_src);
+    ExternalMemoryImageCreateInfo();
+    ~ExternalMemoryImageCreateInfo();
+    void initialize(const VkExternalMemoryImageCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExternalMemoryImageCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkExternalMemoryImageCreateInfo* ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this); }
+    VkExternalMemoryImageCreateInfo const* ptr() const { return reinterpret_cast<VkExternalMemoryImageCreateInfo const*>(this); }
+};
+struct ExternalMemoryBufferCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlags handleTypes;
+
+    ExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    ExternalMemoryBufferCreateInfo(const ExternalMemoryBufferCreateInfo& copy_src);
+    ExternalMemoryBufferCreateInfo& operator=(const ExternalMemoryBufferCreateInfo& copy_src);
+    ExternalMemoryBufferCreateInfo();
+    ~ExternalMemoryBufferCreateInfo();
+    void initialize(const VkExternalMemoryBufferCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExternalMemoryBufferCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkExternalMemoryBufferCreateInfo* ptr() { return reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this); }
+    VkExternalMemoryBufferCreateInfo const* ptr() const { return reinterpret_cast<VkExternalMemoryBufferCreateInfo const*>(this); }
+};
+struct ExportMemoryAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlags handleTypes;
+
+    ExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ExportMemoryAllocateInfo(const ExportMemoryAllocateInfo& copy_src);
+    ExportMemoryAllocateInfo& operator=(const ExportMemoryAllocateInfo& copy_src);
+    ExportMemoryAllocateInfo();
+    ~ExportMemoryAllocateInfo();
+    void initialize(const VkExportMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMemoryAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkExportMemoryAllocateInfo* ptr() { return reinterpret_cast<VkExportMemoryAllocateInfo*>(this); }
+    VkExportMemoryAllocateInfo const* ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfo const*>(this); }
+};
+struct PhysicalDeviceExternalFenceInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalFenceHandleTypeFlagBits handleType;
+
+    PhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    PhysicalDeviceExternalFenceInfo(const PhysicalDeviceExternalFenceInfo& copy_src);
+    PhysicalDeviceExternalFenceInfo& operator=(const PhysicalDeviceExternalFenceInfo& copy_src);
+    PhysicalDeviceExternalFenceInfo();
+    ~PhysicalDeviceExternalFenceInfo();
+    void initialize(const VkPhysicalDeviceExternalFenceInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExternalFenceInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalFenceInfo* ptr() { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this); }
+    VkPhysicalDeviceExternalFenceInfo const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo const*>(this);
+    }
+};
+struct ExternalFenceProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
+    VkExternalFenceHandleTypeFlags compatibleHandleTypes;
+    VkExternalFenceFeatureFlags externalFenceFeatures;
+
+    ExternalFenceProperties(const VkExternalFenceProperties* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ExternalFenceProperties(const ExternalFenceProperties& copy_src);
+    ExternalFenceProperties& operator=(const ExternalFenceProperties& copy_src);
+    ExternalFenceProperties();
+    ~ExternalFenceProperties();
+    void initialize(const VkExternalFenceProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExternalFenceProperties* copy_src, PNextCopyState* copy_state = {});
+    VkExternalFenceProperties* ptr() { return reinterpret_cast<VkExternalFenceProperties*>(this); }
+    VkExternalFenceProperties const* ptr() const { return reinterpret_cast<VkExternalFenceProperties const*>(this); }
+};
+struct ExportFenceCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalFenceHandleTypeFlags handleTypes;
+
+    ExportFenceCreateInfo(const VkExportFenceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ExportFenceCreateInfo(const ExportFenceCreateInfo& copy_src);
+    ExportFenceCreateInfo& operator=(const ExportFenceCreateInfo& copy_src);
+    ExportFenceCreateInfo();
+    ~ExportFenceCreateInfo();
+    void initialize(const VkExportFenceCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportFenceCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkExportFenceCreateInfo* ptr() { return reinterpret_cast<VkExportFenceCreateInfo*>(this); }
+    VkExportFenceCreateInfo const* ptr() const { return reinterpret_cast<VkExportFenceCreateInfo const*>(this); }
+};
+struct ExportSemaphoreCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalSemaphoreHandleTypeFlags handleTypes;
+
+    ExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    ExportSemaphoreCreateInfo(const ExportSemaphoreCreateInfo& copy_src);
+    ExportSemaphoreCreateInfo& operator=(const ExportSemaphoreCreateInfo& copy_src);
+    ExportSemaphoreCreateInfo();
+    ~ExportSemaphoreCreateInfo();
+    void initialize(const VkExportSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportSemaphoreCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkExportSemaphoreCreateInfo* ptr() { return reinterpret_cast<VkExportSemaphoreCreateInfo*>(this); }
+    VkExportSemaphoreCreateInfo const* ptr() const { return reinterpret_cast<VkExportSemaphoreCreateInfo const*>(this); }
+};
+struct PhysicalDeviceExternalSemaphoreInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+
+    PhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    PhysicalDeviceExternalSemaphoreInfo(const PhysicalDeviceExternalSemaphoreInfo& copy_src);
+    PhysicalDeviceExternalSemaphoreInfo& operator=(const PhysicalDeviceExternalSemaphoreInfo& copy_src);
+    PhysicalDeviceExternalSemaphoreInfo();
+    ~PhysicalDeviceExternalSemaphoreInfo();
+    void initialize(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExternalSemaphoreInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalSemaphoreInfo* ptr() { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this); }
+    VkPhysicalDeviceExternalSemaphoreInfo const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo const*>(this);
+    }
+};
+struct ExternalSemaphoreProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
+    VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
+    VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
+
+    ExternalSemaphoreProperties(const VkExternalSemaphoreProperties* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    ExternalSemaphoreProperties(const ExternalSemaphoreProperties& copy_src);
+    ExternalSemaphoreProperties& operator=(const ExternalSemaphoreProperties& copy_src);
+    ExternalSemaphoreProperties();
+    ~ExternalSemaphoreProperties();
+    void initialize(const VkExternalSemaphoreProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExternalSemaphoreProperties* copy_src, PNextCopyState* copy_state = {});
+    VkExternalSemaphoreProperties* ptr() { return reinterpret_cast<VkExternalSemaphoreProperties*>(this); }
+    VkExternalSemaphoreProperties const* ptr() const { return reinterpret_cast<VkExternalSemaphoreProperties const*>(this); }
+};
+struct PhysicalDeviceMaintenance3Properties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxPerSetDescriptors;
+    VkDeviceSize maxMemoryAllocationSize;
+
+    PhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDeviceMaintenance3Properties(const PhysicalDeviceMaintenance3Properties& copy_src);
+    PhysicalDeviceMaintenance3Properties& operator=(const PhysicalDeviceMaintenance3Properties& copy_src);
+    PhysicalDeviceMaintenance3Properties();
+    ~PhysicalDeviceMaintenance3Properties();
+    void initialize(const VkPhysicalDeviceMaintenance3Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMaintenance3Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance3Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(this); }
+    VkPhysicalDeviceMaintenance3Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties const*>(this);
+    }
+};
+struct DescriptorSetLayoutSupport {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 supported;
+
+    DescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    DescriptorSetLayoutSupport(const DescriptorSetLayoutSupport& copy_src);
+    DescriptorSetLayoutSupport& operator=(const DescriptorSetLayoutSupport& copy_src);
+    DescriptorSetLayoutSupport();
+    ~DescriptorSetLayoutSupport();
+    void initialize(const VkDescriptorSetLayoutSupport* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorSetLayoutSupport* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetLayoutSupport* ptr() { return reinterpret_cast<VkDescriptorSetLayoutSupport*>(this); }
+    VkDescriptorSetLayoutSupport const* ptr() const { return reinterpret_cast<VkDescriptorSetLayoutSupport const*>(this); }
+};
+struct PhysicalDeviceShaderDrawParametersFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderDrawParameters;
+
+    PhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderDrawParametersFeatures(const PhysicalDeviceShaderDrawParametersFeatures& copy_src);
+    PhysicalDeviceShaderDrawParametersFeatures& operator=(const PhysicalDeviceShaderDrawParametersFeatures& copy_src);
+    PhysicalDeviceShaderDrawParametersFeatures();
+    ~PhysicalDeviceShaderDrawParametersFeatures();
+    void initialize(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderDrawParametersFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderDrawParametersFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderDrawParametersFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceVulkan11Features {
+    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;
+
+    PhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    PhysicalDeviceVulkan11Features(const PhysicalDeviceVulkan11Features& copy_src);
+    PhysicalDeviceVulkan11Features& operator=(const PhysicalDeviceVulkan11Features& copy_src);
+    PhysicalDeviceVulkan11Features();
+    ~PhysicalDeviceVulkan11Features();
+    void initialize(const VkPhysicalDeviceVulkan11Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVulkan11Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan11Features* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(this); }
+    VkPhysicalDeviceVulkan11Features const* ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan11Features const*>(this); }
+};
+struct PhysicalDeviceVulkan11Properties {
+    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;
+
+    PhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    PhysicalDeviceVulkan11Properties(const PhysicalDeviceVulkan11Properties& copy_src);
+    PhysicalDeviceVulkan11Properties& operator=(const PhysicalDeviceVulkan11Properties& copy_src);
+    PhysicalDeviceVulkan11Properties();
+    ~PhysicalDeviceVulkan11Properties();
+    void initialize(const VkPhysicalDeviceVulkan11Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVulkan11Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan11Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(this); }
+    VkPhysicalDeviceVulkan11Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVulkan11Properties const*>(this);
+    }
+};
+struct PhysicalDeviceVulkan12Features {
+    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;
+
+    PhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    PhysicalDeviceVulkan12Features(const PhysicalDeviceVulkan12Features& copy_src);
+    PhysicalDeviceVulkan12Features& operator=(const PhysicalDeviceVulkan12Features& copy_src);
+    PhysicalDeviceVulkan12Features();
+    ~PhysicalDeviceVulkan12Features();
+    void initialize(const VkPhysicalDeviceVulkan12Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVulkan12Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan12Features* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(this); }
+    VkPhysicalDeviceVulkan12Features const* ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan12Features const*>(this); }
+};
+struct PhysicalDeviceVulkan12Properties {
+    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;
+
+    PhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    PhysicalDeviceVulkan12Properties(const PhysicalDeviceVulkan12Properties& copy_src);
+    PhysicalDeviceVulkan12Properties& operator=(const PhysicalDeviceVulkan12Properties& copy_src);
+    PhysicalDeviceVulkan12Properties();
+    ~PhysicalDeviceVulkan12Properties();
+    void initialize(const VkPhysicalDeviceVulkan12Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVulkan12Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan12Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(this); }
+    VkPhysicalDeviceVulkan12Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVulkan12Properties const*>(this);
+    }
+};
+struct ImageFormatListCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t viewFormatCount;
+    const VkFormat* pViewFormats{};
+
+    ImageFormatListCreateInfo(const VkImageFormatListCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    ImageFormatListCreateInfo(const ImageFormatListCreateInfo& copy_src);
+    ImageFormatListCreateInfo& operator=(const ImageFormatListCreateInfo& copy_src);
+    ImageFormatListCreateInfo();
+    ~ImageFormatListCreateInfo();
+    void initialize(const VkImageFormatListCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageFormatListCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImageFormatListCreateInfo* ptr() { return reinterpret_cast<VkImageFormatListCreateInfo*>(this); }
+    VkImageFormatListCreateInfo const* ptr() const { return reinterpret_cast<VkImageFormatListCreateInfo const*>(this); }
+};
+struct AttachmentDescription2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAttachmentDescriptionFlags flags;
+    VkFormat format;
+    VkSampleCountFlagBits samples;
+    VkAttachmentLoadOp loadOp;
+    VkAttachmentStoreOp storeOp;
+    VkAttachmentLoadOp stencilLoadOp;
+    VkAttachmentStoreOp stencilStoreOp;
+    VkImageLayout initialLayout;
+    VkImageLayout finalLayout;
+
+    AttachmentDescription2(const VkAttachmentDescription2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AttachmentDescription2(const AttachmentDescription2& copy_src);
+    AttachmentDescription2& operator=(const AttachmentDescription2& copy_src);
+    AttachmentDescription2();
+    ~AttachmentDescription2();
+    void initialize(const VkAttachmentDescription2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AttachmentDescription2* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentDescription2* ptr() { return reinterpret_cast<VkAttachmentDescription2*>(this); }
+    VkAttachmentDescription2 const* ptr() const { return reinterpret_cast<VkAttachmentDescription2 const*>(this); }
+};
+struct AttachmentReference2 {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t attachment;
+    VkImageLayout layout;
+    VkImageAspectFlags aspectMask;
+
+    AttachmentReference2(const VkAttachmentReference2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AttachmentReference2(const AttachmentReference2& copy_src);
+    AttachmentReference2& operator=(const AttachmentReference2& copy_src);
+    AttachmentReference2();
+    ~AttachmentReference2();
+    void initialize(const VkAttachmentReference2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AttachmentReference2* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentReference2* ptr() { return reinterpret_cast<VkAttachmentReference2*>(this); }
+    VkAttachmentReference2 const* ptr() const { return reinterpret_cast<VkAttachmentReference2 const*>(this); }
+};
+struct SubpassDescription2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSubpassDescriptionFlags flags;
+    VkPipelineBindPoint pipelineBindPoint;
+    uint32_t viewMask;
+    uint32_t inputAttachmentCount;
+    AttachmentReference2* pInputAttachments{};
+    uint32_t colorAttachmentCount;
+    AttachmentReference2* pColorAttachments{};
+    AttachmentReference2* pResolveAttachments{};
+    AttachmentReference2* pDepthStencilAttachment{};
+    uint32_t preserveAttachmentCount;
+    const uint32_t* pPreserveAttachments{};
+
+    SubpassDescription2(const VkSubpassDescription2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SubpassDescription2(const SubpassDescription2& copy_src);
+    SubpassDescription2& operator=(const SubpassDescription2& copy_src);
+    SubpassDescription2();
+    ~SubpassDescription2();
+    void initialize(const VkSubpassDescription2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubpassDescription2* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassDescription2* ptr() { return reinterpret_cast<VkSubpassDescription2*>(this); }
+    VkSubpassDescription2 const* ptr() const { return reinterpret_cast<VkSubpassDescription2 const*>(this); }
+};
+struct SubpassDependency2 {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t srcSubpass;
+    uint32_t dstSubpass;
+    VkPipelineStageFlags srcStageMask;
+    VkPipelineStageFlags dstStageMask;
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+    VkDependencyFlags dependencyFlags;
+    int32_t viewOffset;
+
+    SubpassDependency2(const VkSubpassDependency2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SubpassDependency2(const SubpassDependency2& copy_src);
+    SubpassDependency2& operator=(const SubpassDependency2& copy_src);
+    SubpassDependency2();
+    ~SubpassDependency2();
+    void initialize(const VkSubpassDependency2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubpassDependency2* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassDependency2* ptr() { return reinterpret_cast<VkSubpassDependency2*>(this); }
+    VkSubpassDependency2 const* ptr() const { return reinterpret_cast<VkSubpassDependency2 const*>(this); }
+};
+struct RenderPassCreateInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPassCreateFlags flags;
+    uint32_t attachmentCount;
+    AttachmentDescription2* pAttachments{};
+    uint32_t subpassCount;
+    SubpassDescription2* pSubpasses{};
+    uint32_t dependencyCount;
+    SubpassDependency2* pDependencies{};
+    uint32_t correlatedViewMaskCount;
+    const uint32_t* pCorrelatedViewMasks{};
+
+    RenderPassCreateInfo2(const VkRenderPassCreateInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderPassCreateInfo2(const RenderPassCreateInfo2& copy_src);
+    RenderPassCreateInfo2& operator=(const RenderPassCreateInfo2& copy_src);
+    RenderPassCreateInfo2();
+    ~RenderPassCreateInfo2();
+    void initialize(const VkRenderPassCreateInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassCreateInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassCreateInfo2* ptr() { return reinterpret_cast<VkRenderPassCreateInfo2*>(this); }
+    VkRenderPassCreateInfo2 const* ptr() const { return reinterpret_cast<VkRenderPassCreateInfo2 const*>(this); }
+};
+struct SubpassBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSubpassContents contents;
+
+    SubpassBeginInfo(const VkSubpassBeginInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SubpassBeginInfo(const SubpassBeginInfo& copy_src);
+    SubpassBeginInfo& operator=(const SubpassBeginInfo& copy_src);
+    SubpassBeginInfo();
+    ~SubpassBeginInfo();
+    void initialize(const VkSubpassBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubpassBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassBeginInfo* ptr() { return reinterpret_cast<VkSubpassBeginInfo*>(this); }
+    VkSubpassBeginInfo const* ptr() const { return reinterpret_cast<VkSubpassBeginInfo const*>(this); }
+};
+struct SubpassEndInfo {
+    VkStructureType sType;
+    const void* pNext{};
+
+    SubpassEndInfo(const VkSubpassEndInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SubpassEndInfo(const SubpassEndInfo& copy_src);
+    SubpassEndInfo& operator=(const SubpassEndInfo& copy_src);
+    SubpassEndInfo();
+    ~SubpassEndInfo();
+    void initialize(const VkSubpassEndInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubpassEndInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassEndInfo* ptr() { return reinterpret_cast<VkSubpassEndInfo*>(this); }
+    VkSubpassEndInfo const* ptr() const { return reinterpret_cast<VkSubpassEndInfo const*>(this); }
+};
+struct PhysicalDevice8BitStorageFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 storageBuffer8BitAccess;
+    VkBool32 uniformAndStorageBuffer8BitAccess;
+    VkBool32 storagePushConstant8;
+
+    PhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    PhysicalDevice8BitStorageFeatures(const PhysicalDevice8BitStorageFeatures& copy_src);
+    PhysicalDevice8BitStorageFeatures& operator=(const PhysicalDevice8BitStorageFeatures& copy_src);
+    PhysicalDevice8BitStorageFeatures();
+    ~PhysicalDevice8BitStorageFeatures();
+    void initialize(const VkPhysicalDevice8BitStorageFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevice8BitStorageFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevice8BitStorageFeatures* ptr() { return reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(this); }
+    VkPhysicalDevice8BitStorageFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevice8BitStorageFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceDriverProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkDriverId driverID;
+    char driverName[VK_MAX_DRIVER_NAME_SIZE];
+    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
+    VkConformanceVersion conformanceVersion;
+
+    PhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    PhysicalDeviceDriverProperties(const PhysicalDeviceDriverProperties& copy_src);
+    PhysicalDeviceDriverProperties& operator=(const PhysicalDeviceDriverProperties& copy_src);
+    PhysicalDeviceDriverProperties();
+    ~PhysicalDeviceDriverProperties();
+    void initialize(const VkPhysicalDeviceDriverProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDriverProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDriverProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceDriverProperties*>(this); }
+    VkPhysicalDeviceDriverProperties const* ptr() const { return reinterpret_cast<VkPhysicalDeviceDriverProperties const*>(this); }
+};
+struct PhysicalDeviceShaderAtomicInt64Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderBufferInt64Atomics;
+    VkBool32 shaderSharedInt64Atomics;
+
+    PhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderAtomicInt64Features(const PhysicalDeviceShaderAtomicInt64Features& copy_src);
+    PhysicalDeviceShaderAtomicInt64Features& operator=(const PhysicalDeviceShaderAtomicInt64Features& copy_src);
+    PhysicalDeviceShaderAtomicInt64Features();
+    ~PhysicalDeviceShaderAtomicInt64Features();
+    void initialize(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderAtomicInt64Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderAtomicInt64Features* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(this); }
+    VkPhysicalDeviceShaderAtomicInt64Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features const*>(this);
+    }
+};
+struct PhysicalDeviceShaderFloat16Int8Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderFloat16;
+    VkBool32 shaderInt8;
+
+    PhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderFloat16Int8Features(const PhysicalDeviceShaderFloat16Int8Features& copy_src);
+    PhysicalDeviceShaderFloat16Int8Features& operator=(const PhysicalDeviceShaderFloat16Int8Features& copy_src);
+    PhysicalDeviceShaderFloat16Int8Features();
+    ~PhysicalDeviceShaderFloat16Int8Features();
+    void initialize(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderFloat16Int8Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderFloat16Int8Features* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(this); }
+    VkPhysicalDeviceShaderFloat16Int8Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features const*>(this);
+    }
+};
+struct PhysicalDeviceFloatControlsProperties {
+    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;
+
+    PhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDeviceFloatControlsProperties(const PhysicalDeviceFloatControlsProperties& copy_src);
+    PhysicalDeviceFloatControlsProperties& operator=(const PhysicalDeviceFloatControlsProperties& copy_src);
+    PhysicalDeviceFloatControlsProperties();
+    ~PhysicalDeviceFloatControlsProperties();
+    void initialize(const VkPhysicalDeviceFloatControlsProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFloatControlsProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFloatControlsProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(this); }
+    VkPhysicalDeviceFloatControlsProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFloatControlsProperties const*>(this);
+    }
+};
+struct DescriptorSetLayoutBindingFlagsCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t bindingCount;
+    const VkDescriptorBindingFlags* pBindingFlags{};
+
+    DescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DescriptorSetLayoutBindingFlagsCreateInfo(const DescriptorSetLayoutBindingFlagsCreateInfo& copy_src);
+    DescriptorSetLayoutBindingFlagsCreateInfo& operator=(const DescriptorSetLayoutBindingFlagsCreateInfo& copy_src);
+    DescriptorSetLayoutBindingFlagsCreateInfo();
+    ~DescriptorSetLayoutBindingFlagsCreateInfo();
+    void initialize(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorSetLayoutBindingFlagsCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetLayoutBindingFlagsCreateInfo* ptr() {
+        return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(this);
+    }
+    VkDescriptorSetLayoutBindingFlagsCreateInfo const* ptr() const {
+        return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo const*>(this);
+    }
+};
+struct PhysicalDeviceDescriptorIndexingFeatures {
+    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;
+
+    PhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDescriptorIndexingFeatures(const PhysicalDeviceDescriptorIndexingFeatures& copy_src);
+    PhysicalDeviceDescriptorIndexingFeatures& operator=(const PhysicalDeviceDescriptorIndexingFeatures& copy_src);
+    PhysicalDeviceDescriptorIndexingFeatures();
+    ~PhysicalDeviceDescriptorIndexingFeatures();
+    void initialize(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDescriptorIndexingFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorIndexingFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(this);
+    }
+    VkPhysicalDeviceDescriptorIndexingFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceDescriptorIndexingProperties {
+    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;
+
+    PhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDescriptorIndexingProperties(const PhysicalDeviceDescriptorIndexingProperties& copy_src);
+    PhysicalDeviceDescriptorIndexingProperties& operator=(const PhysicalDeviceDescriptorIndexingProperties& copy_src);
+    PhysicalDeviceDescriptorIndexingProperties();
+    ~PhysicalDeviceDescriptorIndexingProperties();
+    void initialize(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDescriptorIndexingProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorIndexingProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(this);
+    }
+    VkPhysicalDeviceDescriptorIndexingProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties const*>(this);
+    }
+};
+struct DescriptorSetVariableDescriptorCountAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t descriptorSetCount;
+    const uint32_t* pDescriptorCounts{};
+
+    DescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DescriptorSetVariableDescriptorCountAllocateInfo(const DescriptorSetVariableDescriptorCountAllocateInfo& copy_src);
+    DescriptorSetVariableDescriptorCountAllocateInfo& operator=(const DescriptorSetVariableDescriptorCountAllocateInfo& copy_src);
+    DescriptorSetVariableDescriptorCountAllocateInfo();
+    ~DescriptorSetVariableDescriptorCountAllocateInfo();
+    void initialize(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorSetVariableDescriptorCountAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetVariableDescriptorCountAllocateInfo* ptr() {
+        return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(this);
+    }
+    VkDescriptorSetVariableDescriptorCountAllocateInfo const* ptr() const {
+        return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo const*>(this);
+    }
+};
+struct DescriptorSetVariableDescriptorCountLayoutSupport {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxVariableDescriptorCount;
+
+    DescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DescriptorSetVariableDescriptorCountLayoutSupport(const DescriptorSetVariableDescriptorCountLayoutSupport& copy_src);
+    DescriptorSetVariableDescriptorCountLayoutSupport& operator=(const DescriptorSetVariableDescriptorCountLayoutSupport& copy_src);
+    DescriptorSetVariableDescriptorCountLayoutSupport();
+    ~DescriptorSetVariableDescriptorCountLayoutSupport();
+    void initialize(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorSetVariableDescriptorCountLayoutSupport* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetVariableDescriptorCountLayoutSupport* ptr() {
+        return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(this);
+    }
+    VkDescriptorSetVariableDescriptorCountLayoutSupport const* ptr() const {
+        return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport const*>(this);
+    }
+};
+struct SubpassDescriptionDepthStencilResolve {
+    VkStructureType sType;
+    const void* pNext{};
+    VkResolveModeFlagBits depthResolveMode;
+    VkResolveModeFlagBits stencilResolveMode;
+    AttachmentReference2* pDepthStencilResolveAttachment{};
+
+    SubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    SubpassDescriptionDepthStencilResolve(const SubpassDescriptionDepthStencilResolve& copy_src);
+    SubpassDescriptionDepthStencilResolve& operator=(const SubpassDescriptionDepthStencilResolve& copy_src);
+    SubpassDescriptionDepthStencilResolve();
+    ~SubpassDescriptionDepthStencilResolve();
+    void initialize(const VkSubpassDescriptionDepthStencilResolve* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubpassDescriptionDepthStencilResolve* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassDescriptionDepthStencilResolve* ptr() { return reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(this); }
+    VkSubpassDescriptionDepthStencilResolve const* ptr() const {
+        return reinterpret_cast<VkSubpassDescriptionDepthStencilResolve const*>(this);
+    }
+};
+struct PhysicalDeviceDepthStencilResolveProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkResolveModeFlags supportedDepthResolveModes;
+    VkResolveModeFlags supportedStencilResolveModes;
+    VkBool32 independentResolveNone;
+    VkBool32 independentResolve;
+
+    PhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDepthStencilResolveProperties(const PhysicalDeviceDepthStencilResolveProperties& copy_src);
+    PhysicalDeviceDepthStencilResolveProperties& operator=(const PhysicalDeviceDepthStencilResolveProperties& copy_src);
+    PhysicalDeviceDepthStencilResolveProperties();
+    ~PhysicalDeviceDepthStencilResolveProperties();
+    void initialize(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDepthStencilResolveProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthStencilResolveProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(this);
+    }
+    VkPhysicalDeviceDepthStencilResolveProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties const*>(this);
+    }
+};
+struct PhysicalDeviceScalarBlockLayoutFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 scalarBlockLayout;
+
+    PhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceScalarBlockLayoutFeatures(const PhysicalDeviceScalarBlockLayoutFeatures& copy_src);
+    PhysicalDeviceScalarBlockLayoutFeatures& operator=(const PhysicalDeviceScalarBlockLayoutFeatures& copy_src);
+    PhysicalDeviceScalarBlockLayoutFeatures();
+    ~PhysicalDeviceScalarBlockLayoutFeatures();
+    void initialize(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceScalarBlockLayoutFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceScalarBlockLayoutFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(this); }
+    VkPhysicalDeviceScalarBlockLayoutFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures const*>(this);
+    }
+};
+struct ImageStencilUsageCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageUsageFlags stencilUsage;
+
+    ImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    ImageStencilUsageCreateInfo(const ImageStencilUsageCreateInfo& copy_src);
+    ImageStencilUsageCreateInfo& operator=(const ImageStencilUsageCreateInfo& copy_src);
+    ImageStencilUsageCreateInfo();
+    ~ImageStencilUsageCreateInfo();
+    void initialize(const VkImageStencilUsageCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageStencilUsageCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImageStencilUsageCreateInfo* ptr() { return reinterpret_cast<VkImageStencilUsageCreateInfo*>(this); }
+    VkImageStencilUsageCreateInfo const* ptr() const { return reinterpret_cast<VkImageStencilUsageCreateInfo const*>(this); }
+};
+struct SamplerReductionModeCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSamplerReductionMode reductionMode;
+
+    SamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    SamplerReductionModeCreateInfo(const SamplerReductionModeCreateInfo& copy_src);
+    SamplerReductionModeCreateInfo& operator=(const SamplerReductionModeCreateInfo& copy_src);
+    SamplerReductionModeCreateInfo();
+    ~SamplerReductionModeCreateInfo();
+    void initialize(const VkSamplerReductionModeCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SamplerReductionModeCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerReductionModeCreateInfo* ptr() { return reinterpret_cast<VkSamplerReductionModeCreateInfo*>(this); }
+    VkSamplerReductionModeCreateInfo const* ptr() const { return reinterpret_cast<VkSamplerReductionModeCreateInfo const*>(this); }
+};
+struct PhysicalDeviceSamplerFilterMinmaxProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 filterMinmaxSingleComponentFormats;
+    VkBool32 filterMinmaxImageComponentMapping;
+
+    PhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSamplerFilterMinmaxProperties(const PhysicalDeviceSamplerFilterMinmaxProperties& copy_src);
+    PhysicalDeviceSamplerFilterMinmaxProperties& operator=(const PhysicalDeviceSamplerFilterMinmaxProperties& copy_src);
+    PhysicalDeviceSamplerFilterMinmaxProperties();
+    ~PhysicalDeviceSamplerFilterMinmaxProperties();
+    void initialize(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSamplerFilterMinmaxProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSamplerFilterMinmaxProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(this);
+    }
+    VkPhysicalDeviceSamplerFilterMinmaxProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties const*>(this);
+    }
+};
+struct PhysicalDeviceVulkanMemoryModelFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 vulkanMemoryModel;
+    VkBool32 vulkanMemoryModelDeviceScope;
+    VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
+
+    PhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceVulkanMemoryModelFeatures(const PhysicalDeviceVulkanMemoryModelFeatures& copy_src);
+    PhysicalDeviceVulkanMemoryModelFeatures& operator=(const PhysicalDeviceVulkanMemoryModelFeatures& copy_src);
+    PhysicalDeviceVulkanMemoryModelFeatures();
+    ~PhysicalDeviceVulkanMemoryModelFeatures();
+    void initialize(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVulkanMemoryModelFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkanMemoryModelFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(this); }
+    VkPhysicalDeviceVulkanMemoryModelFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceImagelessFramebufferFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 imagelessFramebuffer;
+
+    PhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceImagelessFramebufferFeatures(const PhysicalDeviceImagelessFramebufferFeatures& copy_src);
+    PhysicalDeviceImagelessFramebufferFeatures& operator=(const PhysicalDeviceImagelessFramebufferFeatures& copy_src);
+    PhysicalDeviceImagelessFramebufferFeatures();
+    ~PhysicalDeviceImagelessFramebufferFeatures();
+    void initialize(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImagelessFramebufferFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImagelessFramebufferFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(this);
+    }
+    VkPhysicalDeviceImagelessFramebufferFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures const*>(this);
+    }
+};
+struct FramebufferAttachmentImageInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageCreateFlags flags;
+    VkImageUsageFlags usage;
+    uint32_t width;
+    uint32_t height;
+    uint32_t layerCount;
+    uint32_t viewFormatCount;
+    const VkFormat* pViewFormats{};
+
+    FramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    FramebufferAttachmentImageInfo(const FramebufferAttachmentImageInfo& copy_src);
+    FramebufferAttachmentImageInfo& operator=(const FramebufferAttachmentImageInfo& copy_src);
+    FramebufferAttachmentImageInfo();
+    ~FramebufferAttachmentImageInfo();
+    void initialize(const VkFramebufferAttachmentImageInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FramebufferAttachmentImageInfo* copy_src, PNextCopyState* copy_state = {});
+    VkFramebufferAttachmentImageInfo* ptr() { return reinterpret_cast<VkFramebufferAttachmentImageInfo*>(this); }
+    VkFramebufferAttachmentImageInfo const* ptr() const { return reinterpret_cast<VkFramebufferAttachmentImageInfo const*>(this); }
+};
+struct FramebufferAttachmentsCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t attachmentImageInfoCount;
+    FramebufferAttachmentImageInfo* pAttachmentImageInfos{};
+
+    FramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    FramebufferAttachmentsCreateInfo(const FramebufferAttachmentsCreateInfo& copy_src);
+    FramebufferAttachmentsCreateInfo& operator=(const FramebufferAttachmentsCreateInfo& copy_src);
+    FramebufferAttachmentsCreateInfo();
+    ~FramebufferAttachmentsCreateInfo();
+    void initialize(const VkFramebufferAttachmentsCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FramebufferAttachmentsCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkFramebufferAttachmentsCreateInfo* ptr() { return reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(this); }
+    VkFramebufferAttachmentsCreateInfo const* ptr() const {
+        return reinterpret_cast<VkFramebufferAttachmentsCreateInfo const*>(this);
+    }
+};
+struct RenderPassAttachmentBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t attachmentCount;
+    VkImageView* pAttachments{};
+
+    RenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    RenderPassAttachmentBeginInfo(const RenderPassAttachmentBeginInfo& copy_src);
+    RenderPassAttachmentBeginInfo& operator=(const RenderPassAttachmentBeginInfo& copy_src);
+    RenderPassAttachmentBeginInfo();
+    ~RenderPassAttachmentBeginInfo();
+    void initialize(const VkRenderPassAttachmentBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassAttachmentBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassAttachmentBeginInfo* ptr() { return reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(this); }
+    VkRenderPassAttachmentBeginInfo const* ptr() const { return reinterpret_cast<VkRenderPassAttachmentBeginInfo const*>(this); }
+};
+struct PhysicalDeviceUniformBufferStandardLayoutFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 uniformBufferStandardLayout;
+
+    PhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceUniformBufferStandardLayoutFeatures(const PhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src);
+    PhysicalDeviceUniformBufferStandardLayoutFeatures& operator=(const PhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src);
+    PhysicalDeviceUniformBufferStandardLayoutFeatures();
+    ~PhysicalDeviceUniformBufferStandardLayoutFeatures();
+    void initialize(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceUniformBufferStandardLayoutFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceUniformBufferStandardLayoutFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(this);
+    }
+    VkPhysicalDeviceUniformBufferStandardLayoutFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderSubgroupExtendedTypes;
+
+    PhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderSubgroupExtendedTypesFeatures(const PhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src);
+    PhysicalDeviceShaderSubgroupExtendedTypesFeatures& operator=(const PhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src);
+    PhysicalDeviceShaderSubgroupExtendedTypesFeatures();
+    ~PhysicalDeviceShaderSubgroupExtendedTypesFeatures();
+    void initialize(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderSubgroupExtendedTypesFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 separateDepthStencilLayouts;
+
+    PhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSeparateDepthStencilLayoutsFeatures(const PhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src);
+    PhysicalDeviceSeparateDepthStencilLayoutsFeatures& operator=(const PhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src);
+    PhysicalDeviceSeparateDepthStencilLayoutsFeatures();
+    ~PhysicalDeviceSeparateDepthStencilLayoutsFeatures();
+    void initialize(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSeparateDepthStencilLayoutsFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(this);
+    }
+    VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const*>(this);
+    }
+};
+struct AttachmentReferenceStencilLayout {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageLayout stencilLayout;
+
+    AttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    AttachmentReferenceStencilLayout(const AttachmentReferenceStencilLayout& copy_src);
+    AttachmentReferenceStencilLayout& operator=(const AttachmentReferenceStencilLayout& copy_src);
+    AttachmentReferenceStencilLayout();
+    ~AttachmentReferenceStencilLayout();
+    void initialize(const VkAttachmentReferenceStencilLayout* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AttachmentReferenceStencilLayout* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentReferenceStencilLayout* ptr() { return reinterpret_cast<VkAttachmentReferenceStencilLayout*>(this); }
+    VkAttachmentReferenceStencilLayout const* ptr() const {
+        return reinterpret_cast<VkAttachmentReferenceStencilLayout const*>(this);
+    }
+};
+struct AttachmentDescriptionStencilLayout {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageLayout stencilInitialLayout;
+    VkImageLayout stencilFinalLayout;
+
+    AttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    AttachmentDescriptionStencilLayout(const AttachmentDescriptionStencilLayout& copy_src);
+    AttachmentDescriptionStencilLayout& operator=(const AttachmentDescriptionStencilLayout& copy_src);
+    AttachmentDescriptionStencilLayout();
+    ~AttachmentDescriptionStencilLayout();
+    void initialize(const VkAttachmentDescriptionStencilLayout* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AttachmentDescriptionStencilLayout* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentDescriptionStencilLayout* ptr() { return reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(this); }
+    VkAttachmentDescriptionStencilLayout const* ptr() const {
+        return reinterpret_cast<VkAttachmentDescriptionStencilLayout const*>(this);
+    }
+};
+struct PhysicalDeviceHostQueryResetFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hostQueryReset;
+
+    PhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDeviceHostQueryResetFeatures(const PhysicalDeviceHostQueryResetFeatures& copy_src);
+    PhysicalDeviceHostQueryResetFeatures& operator=(const PhysicalDeviceHostQueryResetFeatures& copy_src);
+    PhysicalDeviceHostQueryResetFeatures();
+    ~PhysicalDeviceHostQueryResetFeatures();
+    void initialize(const VkPhysicalDeviceHostQueryResetFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceHostQueryResetFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceHostQueryResetFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(this); }
+    VkPhysicalDeviceHostQueryResetFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceTimelineSemaphoreFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 timelineSemaphore;
+
+    PhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceTimelineSemaphoreFeatures(const PhysicalDeviceTimelineSemaphoreFeatures& copy_src);
+    PhysicalDeviceTimelineSemaphoreFeatures& operator=(const PhysicalDeviceTimelineSemaphoreFeatures& copy_src);
+    PhysicalDeviceTimelineSemaphoreFeatures();
+    ~PhysicalDeviceTimelineSemaphoreFeatures();
+    void initialize(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceTimelineSemaphoreFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTimelineSemaphoreFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(this); }
+    VkPhysicalDeviceTimelineSemaphoreFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceTimelineSemaphoreProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t maxTimelineSemaphoreValueDifference;
+
+    PhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceTimelineSemaphoreProperties(const PhysicalDeviceTimelineSemaphoreProperties& copy_src);
+    PhysicalDeviceTimelineSemaphoreProperties& operator=(const PhysicalDeviceTimelineSemaphoreProperties& copy_src);
+    PhysicalDeviceTimelineSemaphoreProperties();
+    ~PhysicalDeviceTimelineSemaphoreProperties();
+    void initialize(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceTimelineSemaphoreProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTimelineSemaphoreProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(this);
+    }
+    VkPhysicalDeviceTimelineSemaphoreProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties const*>(this);
+    }
+};
+struct SemaphoreTypeCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphoreType semaphoreType;
+    uint64_t initialValue;
+
+    SemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SemaphoreTypeCreateInfo(const SemaphoreTypeCreateInfo& copy_src);
+    SemaphoreTypeCreateInfo& operator=(const SemaphoreTypeCreateInfo& copy_src);
+    SemaphoreTypeCreateInfo();
+    ~SemaphoreTypeCreateInfo();
+    void initialize(const VkSemaphoreTypeCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SemaphoreTypeCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreTypeCreateInfo* ptr() { return reinterpret_cast<VkSemaphoreTypeCreateInfo*>(this); }
+    VkSemaphoreTypeCreateInfo const* ptr() const { return reinterpret_cast<VkSemaphoreTypeCreateInfo const*>(this); }
+};
+struct TimelineSemaphoreSubmitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t waitSemaphoreValueCount;
+    const uint64_t* pWaitSemaphoreValues{};
+    uint32_t signalSemaphoreValueCount;
+    const uint64_t* pSignalSemaphoreValues{};
+
+    TimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    TimelineSemaphoreSubmitInfo(const TimelineSemaphoreSubmitInfo& copy_src);
+    TimelineSemaphoreSubmitInfo& operator=(const TimelineSemaphoreSubmitInfo& copy_src);
+    TimelineSemaphoreSubmitInfo();
+    ~TimelineSemaphoreSubmitInfo();
+    void initialize(const VkTimelineSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const TimelineSemaphoreSubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkTimelineSemaphoreSubmitInfo* ptr() { return reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(this); }
+    VkTimelineSemaphoreSubmitInfo const* ptr() const { return reinterpret_cast<VkTimelineSemaphoreSubmitInfo const*>(this); }
+};
+struct SemaphoreWaitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphoreWaitFlags flags;
+    uint32_t semaphoreCount;
+    VkSemaphore* pSemaphores{};
+    const uint64_t* pValues{};
+
+    SemaphoreWaitInfo(const VkSemaphoreWaitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SemaphoreWaitInfo(const SemaphoreWaitInfo& copy_src);
+    SemaphoreWaitInfo& operator=(const SemaphoreWaitInfo& copy_src);
+    SemaphoreWaitInfo();
+    ~SemaphoreWaitInfo();
+    void initialize(const VkSemaphoreWaitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SemaphoreWaitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreWaitInfo* ptr() { return reinterpret_cast<VkSemaphoreWaitInfo*>(this); }
+    VkSemaphoreWaitInfo const* ptr() const { return reinterpret_cast<VkSemaphoreWaitInfo const*>(this); }
+};
+struct SemaphoreSignalInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    uint64_t value;
+
+    SemaphoreSignalInfo(const VkSemaphoreSignalInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SemaphoreSignalInfo(const SemaphoreSignalInfo& copy_src);
+    SemaphoreSignalInfo& operator=(const SemaphoreSignalInfo& copy_src);
+    SemaphoreSignalInfo();
+    ~SemaphoreSignalInfo();
+    void initialize(const VkSemaphoreSignalInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SemaphoreSignalInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreSignalInfo* ptr() { return reinterpret_cast<VkSemaphoreSignalInfo*>(this); }
+    VkSemaphoreSignalInfo const* ptr() const { return reinterpret_cast<VkSemaphoreSignalInfo const*>(this); }
+};
+struct PhysicalDeviceBufferDeviceAddressFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 bufferDeviceAddress;
+    VkBool32 bufferDeviceAddressCaptureReplay;
+    VkBool32 bufferDeviceAddressMultiDevice;
+
+    PhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceBufferDeviceAddressFeatures(const PhysicalDeviceBufferDeviceAddressFeatures& copy_src);
+    PhysicalDeviceBufferDeviceAddressFeatures& operator=(const PhysicalDeviceBufferDeviceAddressFeatures& copy_src);
+    PhysicalDeviceBufferDeviceAddressFeatures();
+    ~PhysicalDeviceBufferDeviceAddressFeatures();
+    void initialize(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceBufferDeviceAddressFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceBufferDeviceAddressFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(this);
+    }
+    VkPhysicalDeviceBufferDeviceAddressFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures const*>(this);
+    }
+};
+struct BufferDeviceAddressInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer buffer;
+
+    BufferDeviceAddressInfo(const VkBufferDeviceAddressInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BufferDeviceAddressInfo(const BufferDeviceAddressInfo& copy_src);
+    BufferDeviceAddressInfo& operator=(const BufferDeviceAddressInfo& copy_src);
+    BufferDeviceAddressInfo();
+    ~BufferDeviceAddressInfo();
+    void initialize(const VkBufferDeviceAddressInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferDeviceAddressInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBufferDeviceAddressInfo* ptr() { return reinterpret_cast<VkBufferDeviceAddressInfo*>(this); }
+    VkBufferDeviceAddressInfo const* ptr() const { return reinterpret_cast<VkBufferDeviceAddressInfo const*>(this); }
+};
+struct BufferOpaqueCaptureAddressCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t opaqueCaptureAddress;
+
+    BufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    BufferOpaqueCaptureAddressCreateInfo(const BufferOpaqueCaptureAddressCreateInfo& copy_src);
+    BufferOpaqueCaptureAddressCreateInfo& operator=(const BufferOpaqueCaptureAddressCreateInfo& copy_src);
+    BufferOpaqueCaptureAddressCreateInfo();
+    ~BufferOpaqueCaptureAddressCreateInfo();
+    void initialize(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferOpaqueCaptureAddressCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBufferOpaqueCaptureAddressCreateInfo* ptr() { return reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(this); }
+    VkBufferOpaqueCaptureAddressCreateInfo const* ptr() const {
+        return reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo const*>(this);
+    }
+};
+struct MemoryOpaqueCaptureAddressAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t opaqueCaptureAddress;
+
+    MemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryOpaqueCaptureAddressAllocateInfo(const MemoryOpaqueCaptureAddressAllocateInfo& copy_src);
+    MemoryOpaqueCaptureAddressAllocateInfo& operator=(const MemoryOpaqueCaptureAddressAllocateInfo& copy_src);
+    MemoryOpaqueCaptureAddressAllocateInfo();
+    ~MemoryOpaqueCaptureAddressAllocateInfo();
+    void initialize(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryOpaqueCaptureAddressAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryOpaqueCaptureAddressAllocateInfo* ptr() { return reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(this); }
+    VkMemoryOpaqueCaptureAddressAllocateInfo const* ptr() const {
+        return reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo const*>(this);
+    }
+};
+struct DeviceMemoryOpaqueCaptureAddressInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+
+    DeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    DeviceMemoryOpaqueCaptureAddressInfo(const DeviceMemoryOpaqueCaptureAddressInfo& copy_src);
+    DeviceMemoryOpaqueCaptureAddressInfo& operator=(const DeviceMemoryOpaqueCaptureAddressInfo& copy_src);
+    DeviceMemoryOpaqueCaptureAddressInfo();
+    ~DeviceMemoryOpaqueCaptureAddressInfo();
+    void initialize(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceMemoryOpaqueCaptureAddressInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceMemoryOpaqueCaptureAddressInfo* ptr() { return reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo*>(this); }
+    VkDeviceMemoryOpaqueCaptureAddressInfo const* ptr() const {
+        return reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo const*>(this);
+    }
+};
+struct PhysicalDeviceVulkan13Features {
+    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;
+
+    PhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    PhysicalDeviceVulkan13Features(const PhysicalDeviceVulkan13Features& copy_src);
+    PhysicalDeviceVulkan13Features& operator=(const PhysicalDeviceVulkan13Features& copy_src);
+    PhysicalDeviceVulkan13Features();
+    ~PhysicalDeviceVulkan13Features();
+    void initialize(const VkPhysicalDeviceVulkan13Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVulkan13Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan13Features* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan13Features*>(this); }
+    VkPhysicalDeviceVulkan13Features const* ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan13Features const*>(this); }
+};
+struct PhysicalDeviceVulkan13Properties {
+    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;
+
+    PhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    PhysicalDeviceVulkan13Properties(const PhysicalDeviceVulkan13Properties& copy_src);
+    PhysicalDeviceVulkan13Properties& operator=(const PhysicalDeviceVulkan13Properties& copy_src);
+    PhysicalDeviceVulkan13Properties();
+    ~PhysicalDeviceVulkan13Properties();
+    void initialize(const VkPhysicalDeviceVulkan13Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVulkan13Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan13Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan13Properties*>(this); }
+    VkPhysicalDeviceVulkan13Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVulkan13Properties const*>(this);
+    }
+};
+struct PipelineCreationFeedbackCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreationFeedback* pPipelineCreationFeedback{};
+    uint32_t pipelineStageCreationFeedbackCount;
+    VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks{};
+
+    PipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    PipelineCreationFeedbackCreateInfo(const PipelineCreationFeedbackCreateInfo& copy_src);
+    PipelineCreationFeedbackCreateInfo& operator=(const PipelineCreationFeedbackCreateInfo& copy_src);
+    PipelineCreationFeedbackCreateInfo();
+    ~PipelineCreationFeedbackCreateInfo();
+    void initialize(const VkPipelineCreationFeedbackCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineCreationFeedbackCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCreationFeedbackCreateInfo* ptr() { return reinterpret_cast<VkPipelineCreationFeedbackCreateInfo*>(this); }
+    VkPipelineCreationFeedbackCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineCreationFeedbackCreateInfo const*>(this);
+    }
+};
+struct PhysicalDeviceShaderTerminateInvocationFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderTerminateInvocation;
+
+    PhysicalDeviceShaderTerminateInvocationFeatures(const VkPhysicalDeviceShaderTerminateInvocationFeatures* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderTerminateInvocationFeatures(const PhysicalDeviceShaderTerminateInvocationFeatures& copy_src);
+    PhysicalDeviceShaderTerminateInvocationFeatures& operator=(const PhysicalDeviceShaderTerminateInvocationFeatures& copy_src);
+    PhysicalDeviceShaderTerminateInvocationFeatures();
+    ~PhysicalDeviceShaderTerminateInvocationFeatures();
+    void initialize(const VkPhysicalDeviceShaderTerminateInvocationFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderTerminateInvocationFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderTerminateInvocationFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceToolProperties {
+    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];
+
+    PhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    PhysicalDeviceToolProperties(const PhysicalDeviceToolProperties& copy_src);
+    PhysicalDeviceToolProperties& operator=(const PhysicalDeviceToolProperties& copy_src);
+    PhysicalDeviceToolProperties();
+    ~PhysicalDeviceToolProperties();
+    void initialize(const VkPhysicalDeviceToolProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceToolProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceToolProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceToolProperties*>(this); }
+    VkPhysicalDeviceToolProperties const* ptr() const { return reinterpret_cast<VkPhysicalDeviceToolProperties const*>(this); }
+};
+struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderDemoteToHelperInvocation;
+
+    PhysicalDeviceShaderDemoteToHelperInvocationFeatures(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderDemoteToHelperInvocationFeatures(const PhysicalDeviceShaderDemoteToHelperInvocationFeatures& copy_src);
+    PhysicalDeviceShaderDemoteToHelperInvocationFeatures& operator=(
+        const PhysicalDeviceShaderDemoteToHelperInvocationFeatures& copy_src);
+    PhysicalDeviceShaderDemoteToHelperInvocationFeatures();
+    ~PhysicalDeviceShaderDemoteToHelperInvocationFeatures();
+    void initialize(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderDemoteToHelperInvocationFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const*>(this);
+    }
+};
+struct PhysicalDevicePrivateDataFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 privateData;
+
+    PhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    PhysicalDevicePrivateDataFeatures(const PhysicalDevicePrivateDataFeatures& copy_src);
+    PhysicalDevicePrivateDataFeatures& operator=(const PhysicalDevicePrivateDataFeatures& copy_src);
+    PhysicalDevicePrivateDataFeatures();
+    ~PhysicalDevicePrivateDataFeatures();
+    void initialize(const VkPhysicalDevicePrivateDataFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePrivateDataFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePrivateDataFeatures* ptr() { return reinterpret_cast<VkPhysicalDevicePrivateDataFeatures*>(this); }
+    VkPhysicalDevicePrivateDataFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePrivateDataFeatures const*>(this);
+    }
+};
+struct DevicePrivateDataCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t privateDataSlotRequestCount;
+
+    DevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    DevicePrivateDataCreateInfo(const DevicePrivateDataCreateInfo& copy_src);
+    DevicePrivateDataCreateInfo& operator=(const DevicePrivateDataCreateInfo& copy_src);
+    DevicePrivateDataCreateInfo();
+    ~DevicePrivateDataCreateInfo();
+    void initialize(const VkDevicePrivateDataCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DevicePrivateDataCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDevicePrivateDataCreateInfo* ptr() { return reinterpret_cast<VkDevicePrivateDataCreateInfo*>(this); }
+    VkDevicePrivateDataCreateInfo const* ptr() const { return reinterpret_cast<VkDevicePrivateDataCreateInfo const*>(this); }
+};
+struct PrivateDataSlotCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPrivateDataSlotCreateFlags flags;
+
+    PrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    PrivateDataSlotCreateInfo(const PrivateDataSlotCreateInfo& copy_src);
+    PrivateDataSlotCreateInfo& operator=(const PrivateDataSlotCreateInfo& copy_src);
+    PrivateDataSlotCreateInfo();
+    ~PrivateDataSlotCreateInfo();
+    void initialize(const VkPrivateDataSlotCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PrivateDataSlotCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPrivateDataSlotCreateInfo* ptr() { return reinterpret_cast<VkPrivateDataSlotCreateInfo*>(this); }
+    VkPrivateDataSlotCreateInfo const* ptr() const { return reinterpret_cast<VkPrivateDataSlotCreateInfo const*>(this); }
+};
+struct PhysicalDevicePipelineCreationCacheControlFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineCreationCacheControl;
+
+    PhysicalDevicePipelineCreationCacheControlFeatures(const VkPhysicalDevicePipelineCreationCacheControlFeatures* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePipelineCreationCacheControlFeatures(const PhysicalDevicePipelineCreationCacheControlFeatures& copy_src);
+    PhysicalDevicePipelineCreationCacheControlFeatures& operator=(
+        const PhysicalDevicePipelineCreationCacheControlFeatures& copy_src);
+    PhysicalDevicePipelineCreationCacheControlFeatures();
+    ~PhysicalDevicePipelineCreationCacheControlFeatures();
+    void initialize(const VkPhysicalDevicePipelineCreationCacheControlFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePipelineCreationCacheControlFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures*>(this);
+    }
+    VkPhysicalDevicePipelineCreationCacheControlFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures const*>(this);
+    }
+};
+struct MemoryBarrier2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineStageFlags2 srcStageMask;
+    VkAccessFlags2 srcAccessMask;
+    VkPipelineStageFlags2 dstStageMask;
+    VkAccessFlags2 dstAccessMask;
+
+    MemoryBarrier2(const VkMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryBarrier2(const MemoryBarrier2& copy_src);
+    MemoryBarrier2& operator=(const MemoryBarrier2& copy_src);
+    MemoryBarrier2();
+    ~MemoryBarrier2();
+    void initialize(const VkMemoryBarrier2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryBarrier2* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryBarrier2* ptr() { return reinterpret_cast<VkMemoryBarrier2*>(this); }
+    VkMemoryBarrier2 const* ptr() const { return reinterpret_cast<VkMemoryBarrier2 const*>(this); }
+};
+struct BufferMemoryBarrier2 {
+    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;
+
+    BufferMemoryBarrier2(const VkBufferMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BufferMemoryBarrier2(const BufferMemoryBarrier2& copy_src);
+    BufferMemoryBarrier2& operator=(const BufferMemoryBarrier2& copy_src);
+    BufferMemoryBarrier2();
+    ~BufferMemoryBarrier2();
+    void initialize(const VkBufferMemoryBarrier2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferMemoryBarrier2* copy_src, PNextCopyState* copy_state = {});
+    VkBufferMemoryBarrier2* ptr() { return reinterpret_cast<VkBufferMemoryBarrier2*>(this); }
+    VkBufferMemoryBarrier2 const* ptr() const { return reinterpret_cast<VkBufferMemoryBarrier2 const*>(this); }
+};
+struct ImageMemoryBarrier2 {
+    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;
+
+    ImageMemoryBarrier2(const VkImageMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageMemoryBarrier2(const ImageMemoryBarrier2& copy_src);
+    ImageMemoryBarrier2& operator=(const ImageMemoryBarrier2& copy_src);
+    ImageMemoryBarrier2();
+    ~ImageMemoryBarrier2();
+    void initialize(const VkImageMemoryBarrier2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageMemoryBarrier2* copy_src, PNextCopyState* copy_state = {});
+    VkImageMemoryBarrier2* ptr() { return reinterpret_cast<VkImageMemoryBarrier2*>(this); }
+    VkImageMemoryBarrier2 const* ptr() const { return reinterpret_cast<VkImageMemoryBarrier2 const*>(this); }
+};
+struct DependencyInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDependencyFlags dependencyFlags;
+    uint32_t memoryBarrierCount;
+    MemoryBarrier2* pMemoryBarriers{};
+    uint32_t bufferMemoryBarrierCount;
+    BufferMemoryBarrier2* pBufferMemoryBarriers{};
+    uint32_t imageMemoryBarrierCount;
+    ImageMemoryBarrier2* pImageMemoryBarriers{};
+
+    DependencyInfo(const VkDependencyInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DependencyInfo(const DependencyInfo& copy_src);
+    DependencyInfo& operator=(const DependencyInfo& copy_src);
+    DependencyInfo();
+    ~DependencyInfo();
+    void initialize(const VkDependencyInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DependencyInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDependencyInfo* ptr() { return reinterpret_cast<VkDependencyInfo*>(this); }
+    VkDependencyInfo const* ptr() const { return reinterpret_cast<VkDependencyInfo const*>(this); }
+};
+struct SemaphoreSubmitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    uint64_t value;
+    VkPipelineStageFlags2 stageMask;
+    uint32_t deviceIndex;
+
+    SemaphoreSubmitInfo(const VkSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SemaphoreSubmitInfo(const SemaphoreSubmitInfo& copy_src);
+    SemaphoreSubmitInfo& operator=(const SemaphoreSubmitInfo& copy_src);
+    SemaphoreSubmitInfo();
+    ~SemaphoreSubmitInfo();
+    void initialize(const VkSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SemaphoreSubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreSubmitInfo* ptr() { return reinterpret_cast<VkSemaphoreSubmitInfo*>(this); }
+    VkSemaphoreSubmitInfo const* ptr() const { return reinterpret_cast<VkSemaphoreSubmitInfo const*>(this); }
+};
+struct CommandBufferSubmitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCommandBuffer commandBuffer;
+    uint32_t deviceMask;
+
+    CommandBufferSubmitInfo(const VkCommandBufferSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CommandBufferSubmitInfo(const CommandBufferSubmitInfo& copy_src);
+    CommandBufferSubmitInfo& operator=(const CommandBufferSubmitInfo& copy_src);
+    CommandBufferSubmitInfo();
+    ~CommandBufferSubmitInfo();
+    void initialize(const VkCommandBufferSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CommandBufferSubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferSubmitInfo* ptr() { return reinterpret_cast<VkCommandBufferSubmitInfo*>(this); }
+    VkCommandBufferSubmitInfo const* ptr() const { return reinterpret_cast<VkCommandBufferSubmitInfo const*>(this); }
+};
+struct SubmitInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSubmitFlags flags;
+    uint32_t waitSemaphoreInfoCount;
+    SemaphoreSubmitInfo* pWaitSemaphoreInfos{};
+    uint32_t commandBufferInfoCount;
+    CommandBufferSubmitInfo* pCommandBufferInfos{};
+    uint32_t signalSemaphoreInfoCount;
+    SemaphoreSubmitInfo* pSignalSemaphoreInfos{};
+
+    SubmitInfo2(const VkSubmitInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SubmitInfo2(const SubmitInfo2& copy_src);
+    SubmitInfo2& operator=(const SubmitInfo2& copy_src);
+    SubmitInfo2();
+    ~SubmitInfo2();
+    void initialize(const VkSubmitInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubmitInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkSubmitInfo2* ptr() { return reinterpret_cast<VkSubmitInfo2*>(this); }
+    VkSubmitInfo2 const* ptr() const { return reinterpret_cast<VkSubmitInfo2 const*>(this); }
+};
+struct PhysicalDeviceSynchronization2Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 synchronization2;
+
+    PhysicalDeviceSynchronization2Features(const VkPhysicalDeviceSynchronization2Features* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSynchronization2Features(const PhysicalDeviceSynchronization2Features& copy_src);
+    PhysicalDeviceSynchronization2Features& operator=(const PhysicalDeviceSynchronization2Features& copy_src);
+    PhysicalDeviceSynchronization2Features();
+    ~PhysicalDeviceSynchronization2Features();
+    void initialize(const VkPhysicalDeviceSynchronization2Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSynchronization2Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSynchronization2Features* ptr() { return reinterpret_cast<VkPhysicalDeviceSynchronization2Features*>(this); }
+    VkPhysicalDeviceSynchronization2Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSynchronization2Features const*>(this);
+    }
+};
+struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderZeroInitializeWorkgroupMemory;
+
+    PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(const PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& copy_src);
+    PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& operator=(
+        const PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& copy_src);
+    PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures();
+    ~PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures();
+    void initialize(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(this);
+    }
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceImageRobustnessFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 robustImageAccess;
+
+    PhysicalDeviceImageRobustnessFeatures(const VkPhysicalDeviceImageRobustnessFeatures* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDeviceImageRobustnessFeatures(const PhysicalDeviceImageRobustnessFeatures& copy_src);
+    PhysicalDeviceImageRobustnessFeatures& operator=(const PhysicalDeviceImageRobustnessFeatures& copy_src);
+    PhysicalDeviceImageRobustnessFeatures();
+    ~PhysicalDeviceImageRobustnessFeatures();
+    void initialize(const VkPhysicalDeviceImageRobustnessFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageRobustnessFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageRobustnessFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceImageRobustnessFeatures*>(this); }
+    VkPhysicalDeviceImageRobustnessFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageRobustnessFeatures const*>(this);
+    }
+};
+struct BufferCopy2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize srcOffset;
+    VkDeviceSize dstOffset;
+    VkDeviceSize size;
+
+    BufferCopy2(const VkBufferCopy2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BufferCopy2(const BufferCopy2& copy_src);
+    BufferCopy2& operator=(const BufferCopy2& copy_src);
+    BufferCopy2();
+    ~BufferCopy2();
+    void initialize(const VkBufferCopy2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferCopy2* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCopy2* ptr() { return reinterpret_cast<VkBufferCopy2*>(this); }
+    VkBufferCopy2 const* ptr() const { return reinterpret_cast<VkBufferCopy2 const*>(this); }
+};
+struct CopyBufferInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer srcBuffer;
+    VkBuffer dstBuffer;
+    uint32_t regionCount;
+    BufferCopy2* pRegions{};
+
+    CopyBufferInfo2(const VkCopyBufferInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CopyBufferInfo2(const CopyBufferInfo2& copy_src);
+    CopyBufferInfo2& operator=(const CopyBufferInfo2& copy_src);
+    CopyBufferInfo2();
+    ~CopyBufferInfo2();
+    void initialize(const VkCopyBufferInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyBufferInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkCopyBufferInfo2* ptr() { return reinterpret_cast<VkCopyBufferInfo2*>(this); }
+    VkCopyBufferInfo2 const* ptr() const { return reinterpret_cast<VkCopyBufferInfo2 const*>(this); }
+};
+struct ImageCopy2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageSubresourceLayers srcSubresource;
+    VkOffset3D srcOffset;
+    VkImageSubresourceLayers dstSubresource;
+    VkOffset3D dstOffset;
+    VkExtent3D extent;
+
+    ImageCopy2(const VkImageCopy2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageCopy2(const ImageCopy2& copy_src);
+    ImageCopy2& operator=(const ImageCopy2& copy_src);
+    ImageCopy2();
+    ~ImageCopy2();
+    void initialize(const VkImageCopy2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageCopy2* copy_src, PNextCopyState* copy_state = {});
+    VkImageCopy2* ptr() { return reinterpret_cast<VkImageCopy2*>(this); }
+    VkImageCopy2 const* ptr() const { return reinterpret_cast<VkImageCopy2 const*>(this); }
+};
+struct CopyImageInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    ImageCopy2* pRegions{};
+
+    CopyImageInfo2(const VkCopyImageInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CopyImageInfo2(const CopyImageInfo2& copy_src);
+    CopyImageInfo2& operator=(const CopyImageInfo2& copy_src);
+    CopyImageInfo2();
+    ~CopyImageInfo2();
+    void initialize(const VkCopyImageInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyImageInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkCopyImageInfo2* ptr() { return reinterpret_cast<VkCopyImageInfo2*>(this); }
+    VkCopyImageInfo2 const* ptr() const { return reinterpret_cast<VkCopyImageInfo2 const*>(this); }
+};
+struct BufferImageCopy2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize bufferOffset;
+    uint32_t bufferRowLength;
+    uint32_t bufferImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+
+    BufferImageCopy2(const VkBufferImageCopy2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BufferImageCopy2(const BufferImageCopy2& copy_src);
+    BufferImageCopy2& operator=(const BufferImageCopy2& copy_src);
+    BufferImageCopy2();
+    ~BufferImageCopy2();
+    void initialize(const VkBufferImageCopy2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferImageCopy2* copy_src, PNextCopyState* copy_state = {});
+    VkBufferImageCopy2* ptr() { return reinterpret_cast<VkBufferImageCopy2*>(this); }
+    VkBufferImageCopy2 const* ptr() const { return reinterpret_cast<VkBufferImageCopy2 const*>(this); }
+};
+struct CopyBufferToImageInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer srcBuffer;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    BufferImageCopy2* pRegions{};
+
+    CopyBufferToImageInfo2(const VkCopyBufferToImageInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CopyBufferToImageInfo2(const CopyBufferToImageInfo2& copy_src);
+    CopyBufferToImageInfo2& operator=(const CopyBufferToImageInfo2& copy_src);
+    CopyBufferToImageInfo2();
+    ~CopyBufferToImageInfo2();
+    void initialize(const VkCopyBufferToImageInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyBufferToImageInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkCopyBufferToImageInfo2* ptr() { return reinterpret_cast<VkCopyBufferToImageInfo2*>(this); }
+    VkCopyBufferToImageInfo2 const* ptr() const { return reinterpret_cast<VkCopyBufferToImageInfo2 const*>(this); }
+};
+struct CopyImageToBufferInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    VkBuffer dstBuffer;
+    uint32_t regionCount;
+    BufferImageCopy2* pRegions{};
+
+    CopyImageToBufferInfo2(const VkCopyImageToBufferInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CopyImageToBufferInfo2(const CopyImageToBufferInfo2& copy_src);
+    CopyImageToBufferInfo2& operator=(const CopyImageToBufferInfo2& copy_src);
+    CopyImageToBufferInfo2();
+    ~CopyImageToBufferInfo2();
+    void initialize(const VkCopyImageToBufferInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyImageToBufferInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkCopyImageToBufferInfo2* ptr() { return reinterpret_cast<VkCopyImageToBufferInfo2*>(this); }
+    VkCopyImageToBufferInfo2 const* ptr() const { return reinterpret_cast<VkCopyImageToBufferInfo2 const*>(this); }
+};
+struct ImageBlit2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageSubresourceLayers srcSubresource;
+    VkOffset3D srcOffsets[2];
+    VkImageSubresourceLayers dstSubresource;
+    VkOffset3D dstOffsets[2];
+
+    ImageBlit2(const VkImageBlit2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageBlit2(const ImageBlit2& copy_src);
+    ImageBlit2& operator=(const ImageBlit2& copy_src);
+    ImageBlit2();
+    ~ImageBlit2();
+    void initialize(const VkImageBlit2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageBlit2* copy_src, PNextCopyState* copy_state = {});
+    VkImageBlit2* ptr() { return reinterpret_cast<VkImageBlit2*>(this); }
+    VkImageBlit2 const* ptr() const { return reinterpret_cast<VkImageBlit2 const*>(this); }
+};
+struct BlitImageInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    ImageBlit2* pRegions{};
+    VkFilter filter;
+
+    BlitImageInfo2(const VkBlitImageInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BlitImageInfo2(const BlitImageInfo2& copy_src);
+    BlitImageInfo2& operator=(const BlitImageInfo2& copy_src);
+    BlitImageInfo2();
+    ~BlitImageInfo2();
+    void initialize(const VkBlitImageInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BlitImageInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkBlitImageInfo2* ptr() { return reinterpret_cast<VkBlitImageInfo2*>(this); }
+    VkBlitImageInfo2 const* ptr() const { return reinterpret_cast<VkBlitImageInfo2 const*>(this); }
+};
+struct ImageResolve2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageSubresourceLayers srcSubresource;
+    VkOffset3D srcOffset;
+    VkImageSubresourceLayers dstSubresource;
+    VkOffset3D dstOffset;
+    VkExtent3D extent;
+
+    ImageResolve2(const VkImageResolve2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageResolve2(const ImageResolve2& copy_src);
+    ImageResolve2& operator=(const ImageResolve2& copy_src);
+    ImageResolve2();
+    ~ImageResolve2();
+    void initialize(const VkImageResolve2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageResolve2* copy_src, PNextCopyState* copy_state = {});
+    VkImageResolve2* ptr() { return reinterpret_cast<VkImageResolve2*>(this); }
+    VkImageResolve2 const* ptr() const { return reinterpret_cast<VkImageResolve2 const*>(this); }
+};
+struct ResolveImageInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    ImageResolve2* pRegions{};
+
+    ResolveImageInfo2(const VkResolveImageInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ResolveImageInfo2(const ResolveImageInfo2& copy_src);
+    ResolveImageInfo2& operator=(const ResolveImageInfo2& copy_src);
+    ResolveImageInfo2();
+    ~ResolveImageInfo2();
+    void initialize(const VkResolveImageInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ResolveImageInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkResolveImageInfo2* ptr() { return reinterpret_cast<VkResolveImageInfo2*>(this); }
+    VkResolveImageInfo2 const* ptr() const { return reinterpret_cast<VkResolveImageInfo2 const*>(this); }
+};
+struct PhysicalDeviceSubgroupSizeControlFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 subgroupSizeControl;
+    VkBool32 computeFullSubgroups;
+
+    PhysicalDeviceSubgroupSizeControlFeatures(const VkPhysicalDeviceSubgroupSizeControlFeatures* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSubgroupSizeControlFeatures(const PhysicalDeviceSubgroupSizeControlFeatures& copy_src);
+    PhysicalDeviceSubgroupSizeControlFeatures& operator=(const PhysicalDeviceSubgroupSizeControlFeatures& copy_src);
+    PhysicalDeviceSubgroupSizeControlFeatures();
+    ~PhysicalDeviceSubgroupSizeControlFeatures();
+    void initialize(const VkPhysicalDeviceSubgroupSizeControlFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSubgroupSizeControlFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubgroupSizeControlFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(this);
+    }
+    VkPhysicalDeviceSubgroupSizeControlFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceSubgroupSizeControlProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t minSubgroupSize;
+    uint32_t maxSubgroupSize;
+    uint32_t maxComputeWorkgroupSubgroups;
+    VkShaderStageFlags requiredSubgroupSizeStages;
+
+    PhysicalDeviceSubgroupSizeControlProperties(const VkPhysicalDeviceSubgroupSizeControlProperties* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSubgroupSizeControlProperties(const PhysicalDeviceSubgroupSizeControlProperties& copy_src);
+    PhysicalDeviceSubgroupSizeControlProperties& operator=(const PhysicalDeviceSubgroupSizeControlProperties& copy_src);
+    PhysicalDeviceSubgroupSizeControlProperties();
+    ~PhysicalDeviceSubgroupSizeControlProperties();
+    void initialize(const VkPhysicalDeviceSubgroupSizeControlProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSubgroupSizeControlProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubgroupSizeControlProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlProperties*>(this);
+    }
+    VkPhysicalDeviceSubgroupSizeControlProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlProperties const*>(this);
+    }
+};
+struct PipelineShaderStageRequiredSubgroupSizeCreateInfo {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t requiredSubgroupSize;
+
+    PipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineShaderStageRequiredSubgroupSizeCreateInfo(const PipelineShaderStageRequiredSubgroupSizeCreateInfo& copy_src);
+    PipelineShaderStageRequiredSubgroupSizeCreateInfo& operator=(const PipelineShaderStageRequiredSubgroupSizeCreateInfo& copy_src);
+    PipelineShaderStageRequiredSubgroupSizeCreateInfo();
+    ~PipelineShaderStageRequiredSubgroupSizeCreateInfo();
+    void initialize(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineShaderStageRequiredSubgroupSizeCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* ptr() {
+        return reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(this);
+    }
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const*>(this);
+    }
+};
+struct PhysicalDeviceInlineUniformBlockFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 inlineUniformBlock;
+    VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
+
+    PhysicalDeviceInlineUniformBlockFeatures(const VkPhysicalDeviceInlineUniformBlockFeatures* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceInlineUniformBlockFeatures(const PhysicalDeviceInlineUniformBlockFeatures& copy_src);
+    PhysicalDeviceInlineUniformBlockFeatures& operator=(const PhysicalDeviceInlineUniformBlockFeatures& copy_src);
+    PhysicalDeviceInlineUniformBlockFeatures();
+    ~PhysicalDeviceInlineUniformBlockFeatures();
+    void initialize(const VkPhysicalDeviceInlineUniformBlockFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceInlineUniformBlockFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceInlineUniformBlockFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(this);
+    }
+    VkPhysicalDeviceInlineUniformBlockFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceInlineUniformBlockProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxInlineUniformBlockSize;
+    uint32_t maxPerStageDescriptorInlineUniformBlocks;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    uint32_t maxDescriptorSetInlineUniformBlocks;
+    uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+
+    PhysicalDeviceInlineUniformBlockProperties(const VkPhysicalDeviceInlineUniformBlockProperties* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceInlineUniformBlockProperties(const PhysicalDeviceInlineUniformBlockProperties& copy_src);
+    PhysicalDeviceInlineUniformBlockProperties& operator=(const PhysicalDeviceInlineUniformBlockProperties& copy_src);
+    PhysicalDeviceInlineUniformBlockProperties();
+    ~PhysicalDeviceInlineUniformBlockProperties();
+    void initialize(const VkPhysicalDeviceInlineUniformBlockProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceInlineUniformBlockProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceInlineUniformBlockProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockProperties*>(this);
+    }
+    VkPhysicalDeviceInlineUniformBlockProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockProperties const*>(this);
+    }
+};
+struct WriteDescriptorSetInlineUniformBlock {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t dataSize;
+    const void* pData{};
+
+    WriteDescriptorSetInlineUniformBlock(const VkWriteDescriptorSetInlineUniformBlock* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    WriteDescriptorSetInlineUniformBlock(const WriteDescriptorSetInlineUniformBlock& copy_src);
+    WriteDescriptorSetInlineUniformBlock& operator=(const WriteDescriptorSetInlineUniformBlock& copy_src);
+    WriteDescriptorSetInlineUniformBlock();
+    ~WriteDescriptorSetInlineUniformBlock();
+    void initialize(const VkWriteDescriptorSetInlineUniformBlock* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const WriteDescriptorSetInlineUniformBlock* copy_src, PNextCopyState* copy_state = {});
+    VkWriteDescriptorSetInlineUniformBlock* ptr() { return reinterpret_cast<VkWriteDescriptorSetInlineUniformBlock*>(this); }
+    VkWriteDescriptorSetInlineUniformBlock const* ptr() const {
+        return reinterpret_cast<VkWriteDescriptorSetInlineUniformBlock const*>(this);
+    }
+};
+struct DescriptorPoolInlineUniformBlockCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxInlineUniformBlockBindings;
+
+    DescriptorPoolInlineUniformBlockCreateInfo(const VkDescriptorPoolInlineUniformBlockCreateInfo* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DescriptorPoolInlineUniformBlockCreateInfo(const DescriptorPoolInlineUniformBlockCreateInfo& copy_src);
+    DescriptorPoolInlineUniformBlockCreateInfo& operator=(const DescriptorPoolInlineUniformBlockCreateInfo& copy_src);
+    DescriptorPoolInlineUniformBlockCreateInfo();
+    ~DescriptorPoolInlineUniformBlockCreateInfo();
+    void initialize(const VkDescriptorPoolInlineUniformBlockCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorPoolInlineUniformBlockCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorPoolInlineUniformBlockCreateInfo* ptr() {
+        return reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo*>(this);
+    }
+    VkDescriptorPoolInlineUniformBlockCreateInfo const* ptr() const {
+        return reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo const*>(this);
+    }
+};
+struct PhysicalDeviceTextureCompressionASTCHDRFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 textureCompressionASTC_HDR;
+
+    PhysicalDeviceTextureCompressionASTCHDRFeatures(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceTextureCompressionASTCHDRFeatures(const PhysicalDeviceTextureCompressionASTCHDRFeatures& copy_src);
+    PhysicalDeviceTextureCompressionASTCHDRFeatures& operator=(const PhysicalDeviceTextureCompressionASTCHDRFeatures& copy_src);
+    PhysicalDeviceTextureCompressionASTCHDRFeatures();
+    ~PhysicalDeviceTextureCompressionASTCHDRFeatures();
+    void initialize(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceTextureCompressionASTCHDRFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(this);
+    }
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures const*>(this);
+    }
+};
+struct RenderingAttachmentInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+    VkImageLayout imageLayout;
+    VkResolveModeFlagBits resolveMode;
+    VkImageView resolveImageView;
+    VkImageLayout resolveImageLayout;
+    VkAttachmentLoadOp loadOp;
+    VkAttachmentStoreOp storeOp;
+    VkClearValue clearValue;
+
+    RenderingAttachmentInfo(const VkRenderingAttachmentInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderingAttachmentInfo(const RenderingAttachmentInfo& copy_src);
+    RenderingAttachmentInfo& operator=(const RenderingAttachmentInfo& copy_src);
+    RenderingAttachmentInfo();
+    ~RenderingAttachmentInfo();
+    void initialize(const VkRenderingAttachmentInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderingAttachmentInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingAttachmentInfo* ptr() { return reinterpret_cast<VkRenderingAttachmentInfo*>(this); }
+    VkRenderingAttachmentInfo const* ptr() const { return reinterpret_cast<VkRenderingAttachmentInfo const*>(this); }
+};
+struct RenderingInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderingFlags flags;
+    VkRect2D renderArea;
+    uint32_t layerCount;
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    RenderingAttachmentInfo* pColorAttachments{};
+    RenderingAttachmentInfo* pDepthAttachment{};
+    RenderingAttachmentInfo* pStencilAttachment{};
+
+    RenderingInfo(const VkRenderingInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderingInfo(const RenderingInfo& copy_src);
+    RenderingInfo& operator=(const RenderingInfo& copy_src);
+    RenderingInfo();
+    ~RenderingInfo();
+    void initialize(const VkRenderingInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderingInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingInfo* ptr() { return reinterpret_cast<VkRenderingInfo*>(this); }
+    VkRenderingInfo const* ptr() const { return reinterpret_cast<VkRenderingInfo const*>(this); }
+};
+struct PipelineRenderingCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    const VkFormat* pColorAttachmentFormats{};
+    VkFormat depthAttachmentFormat;
+    VkFormat stencilAttachmentFormat;
+
+    PipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    PipelineRenderingCreateInfo(const PipelineRenderingCreateInfo& copy_src);
+    PipelineRenderingCreateInfo& operator=(const PipelineRenderingCreateInfo& copy_src);
+    PipelineRenderingCreateInfo();
+    ~PipelineRenderingCreateInfo();
+    void initialize(const VkPipelineRenderingCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineRenderingCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRenderingCreateInfo* ptr() { return reinterpret_cast<VkPipelineRenderingCreateInfo*>(this); }
+    VkPipelineRenderingCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineRenderingCreateInfo const*>(this); }
+};
+struct PhysicalDeviceDynamicRenderingFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 dynamicRendering;
+
+    PhysicalDeviceDynamicRenderingFeatures(const VkPhysicalDeviceDynamicRenderingFeatures* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDynamicRenderingFeatures(const PhysicalDeviceDynamicRenderingFeatures& copy_src);
+    PhysicalDeviceDynamicRenderingFeatures& operator=(const PhysicalDeviceDynamicRenderingFeatures& copy_src);
+    PhysicalDeviceDynamicRenderingFeatures();
+    ~PhysicalDeviceDynamicRenderingFeatures();
+    void initialize(const VkPhysicalDeviceDynamicRenderingFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDynamicRenderingFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDynamicRenderingFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeatures*>(this); }
+    VkPhysicalDeviceDynamicRenderingFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeatures const*>(this);
+    }
+};
+struct CommandBufferInheritanceRenderingInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderingFlags flags;
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    const VkFormat* pColorAttachmentFormats{};
+    VkFormat depthAttachmentFormat;
+    VkFormat stencilAttachmentFormat;
+    VkSampleCountFlagBits rasterizationSamples;
+
+    CommandBufferInheritanceRenderingInfo(const VkCommandBufferInheritanceRenderingInfo* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    CommandBufferInheritanceRenderingInfo(const CommandBufferInheritanceRenderingInfo& copy_src);
+    CommandBufferInheritanceRenderingInfo& operator=(const CommandBufferInheritanceRenderingInfo& copy_src);
+    CommandBufferInheritanceRenderingInfo();
+    ~CommandBufferInheritanceRenderingInfo();
+    void initialize(const VkCommandBufferInheritanceRenderingInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CommandBufferInheritanceRenderingInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferInheritanceRenderingInfo* ptr() { return reinterpret_cast<VkCommandBufferInheritanceRenderingInfo*>(this); }
+    VkCommandBufferInheritanceRenderingInfo const* ptr() const {
+        return reinterpret_cast<VkCommandBufferInheritanceRenderingInfo const*>(this);
+    }
+};
+struct PhysicalDeviceShaderIntegerDotProductFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderIntegerDotProduct;
+
+    PhysicalDeviceShaderIntegerDotProductFeatures(const VkPhysicalDeviceShaderIntegerDotProductFeatures* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderIntegerDotProductFeatures(const PhysicalDeviceShaderIntegerDotProductFeatures& copy_src);
+    PhysicalDeviceShaderIntegerDotProductFeatures& operator=(const PhysicalDeviceShaderIntegerDotProductFeatures& copy_src);
+    PhysicalDeviceShaderIntegerDotProductFeatures();
+    ~PhysicalDeviceShaderIntegerDotProductFeatures();
+    void initialize(const VkPhysicalDeviceShaderIntegerDotProductFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderIntegerDotProductFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderIntegerDotProductFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures const*>(this);
+    }
+};
+struct PhysicalDeviceShaderIntegerDotProductProperties {
+    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;
+
+    PhysicalDeviceShaderIntegerDotProductProperties(const VkPhysicalDeviceShaderIntegerDotProductProperties* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderIntegerDotProductProperties(const PhysicalDeviceShaderIntegerDotProductProperties& copy_src);
+    PhysicalDeviceShaderIntegerDotProductProperties& operator=(const PhysicalDeviceShaderIntegerDotProductProperties& copy_src);
+    PhysicalDeviceShaderIntegerDotProductProperties();
+    ~PhysicalDeviceShaderIntegerDotProductProperties();
+    void initialize(const VkPhysicalDeviceShaderIntegerDotProductProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderIntegerDotProductProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderIntegerDotProductProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductProperties*>(this);
+    }
+    VkPhysicalDeviceShaderIntegerDotProductProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductProperties const*>(this);
+    }
+};
+struct PhysicalDeviceTexelBufferAlignmentProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize storageTexelBufferOffsetAlignmentBytes;
+    VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
+    VkDeviceSize uniformTexelBufferOffsetAlignmentBytes;
+    VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
+
+    PhysicalDeviceTexelBufferAlignmentProperties(const VkPhysicalDeviceTexelBufferAlignmentProperties* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceTexelBufferAlignmentProperties(const PhysicalDeviceTexelBufferAlignmentProperties& copy_src);
+    PhysicalDeviceTexelBufferAlignmentProperties& operator=(const PhysicalDeviceTexelBufferAlignmentProperties& copy_src);
+    PhysicalDeviceTexelBufferAlignmentProperties();
+    ~PhysicalDeviceTexelBufferAlignmentProperties();
+    void initialize(const VkPhysicalDeviceTexelBufferAlignmentProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceTexelBufferAlignmentProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTexelBufferAlignmentProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentProperties*>(this);
+    }
+    VkPhysicalDeviceTexelBufferAlignmentProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentProperties const*>(this);
+    }
+};
+struct FormatProperties3 {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormatFeatureFlags2 linearTilingFeatures;
+    VkFormatFeatureFlags2 optimalTilingFeatures;
+    VkFormatFeatureFlags2 bufferFeatures;
+
+    FormatProperties3(const VkFormatProperties3* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    FormatProperties3(const FormatProperties3& copy_src);
+    FormatProperties3& operator=(const FormatProperties3& copy_src);
+    FormatProperties3();
+    ~FormatProperties3();
+    void initialize(const VkFormatProperties3* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FormatProperties3* copy_src, PNextCopyState* copy_state = {});
+    VkFormatProperties3* ptr() { return reinterpret_cast<VkFormatProperties3*>(this); }
+    VkFormatProperties3 const* ptr() const { return reinterpret_cast<VkFormatProperties3 const*>(this); }
+};
+struct PhysicalDeviceMaintenance4Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 maintenance4;
+
+    PhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    PhysicalDeviceMaintenance4Features(const PhysicalDeviceMaintenance4Features& copy_src);
+    PhysicalDeviceMaintenance4Features& operator=(const PhysicalDeviceMaintenance4Features& copy_src);
+    PhysicalDeviceMaintenance4Features();
+    ~PhysicalDeviceMaintenance4Features();
+    void initialize(const VkPhysicalDeviceMaintenance4Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMaintenance4Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance4Features* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance4Features*>(this); }
+    VkPhysicalDeviceMaintenance4Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance4Features const*>(this);
+    }
+};
+struct PhysicalDeviceMaintenance4Properties {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize maxBufferSize;
+
+    PhysicalDeviceMaintenance4Properties(const VkPhysicalDeviceMaintenance4Properties* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDeviceMaintenance4Properties(const PhysicalDeviceMaintenance4Properties& copy_src);
+    PhysicalDeviceMaintenance4Properties& operator=(const PhysicalDeviceMaintenance4Properties& copy_src);
+    PhysicalDeviceMaintenance4Properties();
+    ~PhysicalDeviceMaintenance4Properties();
+    void initialize(const VkPhysicalDeviceMaintenance4Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMaintenance4Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance4Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance4Properties*>(this); }
+    VkPhysicalDeviceMaintenance4Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance4Properties const*>(this);
+    }
+};
+struct DeviceBufferMemoryRequirements {
+    VkStructureType sType;
+    const void* pNext{};
+    BufferCreateInfo* pCreateInfo{};
+
+    DeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    DeviceBufferMemoryRequirements(const DeviceBufferMemoryRequirements& copy_src);
+    DeviceBufferMemoryRequirements& operator=(const DeviceBufferMemoryRequirements& copy_src);
+    DeviceBufferMemoryRequirements();
+    ~DeviceBufferMemoryRequirements();
+    void initialize(const VkDeviceBufferMemoryRequirements* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceBufferMemoryRequirements* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceBufferMemoryRequirements* ptr() { return reinterpret_cast<VkDeviceBufferMemoryRequirements*>(this); }
+    VkDeviceBufferMemoryRequirements const* ptr() const { return reinterpret_cast<VkDeviceBufferMemoryRequirements const*>(this); }
+};
+struct DeviceImageMemoryRequirements {
+    VkStructureType sType;
+    const void* pNext{};
+    ImageCreateInfo* pCreateInfo{};
+    VkImageAspectFlagBits planeAspect;
+
+    DeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    DeviceImageMemoryRequirements(const DeviceImageMemoryRequirements& copy_src);
+    DeviceImageMemoryRequirements& operator=(const DeviceImageMemoryRequirements& copy_src);
+    DeviceImageMemoryRequirements();
+    ~DeviceImageMemoryRequirements();
+    void initialize(const VkDeviceImageMemoryRequirements* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceImageMemoryRequirements* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceImageMemoryRequirements* ptr() { return reinterpret_cast<VkDeviceImageMemoryRequirements*>(this); }
+    VkDeviceImageMemoryRequirements const* ptr() const { return reinterpret_cast<VkDeviceImageMemoryRequirements const*>(this); }
+};
+struct SwapchainCreateInfoKHR {
+    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;
+
+    SwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SwapchainCreateInfoKHR(const SwapchainCreateInfoKHR& copy_src);
+    SwapchainCreateInfoKHR& operator=(const SwapchainCreateInfoKHR& copy_src);
+    SwapchainCreateInfoKHR();
+    ~SwapchainCreateInfoKHR();
+    void initialize(const VkSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SwapchainCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainCreateInfoKHR* ptr() { return reinterpret_cast<VkSwapchainCreateInfoKHR*>(this); }
+    VkSwapchainCreateInfoKHR const* ptr() const { return reinterpret_cast<VkSwapchainCreateInfoKHR const*>(this); }
+};
+struct PresentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t waitSemaphoreCount;
+    VkSemaphore* pWaitSemaphores{};
+    uint32_t swapchainCount;
+    VkSwapchainKHR* pSwapchains{};
+    const uint32_t* pImageIndices{};
+    VkResult* pResults{};
+
+    PresentInfoKHR(const VkPresentInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PresentInfoKHR(const PresentInfoKHR& copy_src);
+    PresentInfoKHR& operator=(const PresentInfoKHR& copy_src);
+    PresentInfoKHR();
+    ~PresentInfoKHR();
+    void initialize(const VkPresentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PresentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPresentInfoKHR* ptr() { return reinterpret_cast<VkPresentInfoKHR*>(this); }
+    VkPresentInfoKHR const* ptr() const { return reinterpret_cast<VkPresentInfoKHR const*>(this); }
+};
+struct ImageSwapchainCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSwapchainKHR swapchain;
+
+    ImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    ImageSwapchainCreateInfoKHR(const ImageSwapchainCreateInfoKHR& copy_src);
+    ImageSwapchainCreateInfoKHR& operator=(const ImageSwapchainCreateInfoKHR& copy_src);
+    ImageSwapchainCreateInfoKHR();
+    ~ImageSwapchainCreateInfoKHR();
+    void initialize(const VkImageSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageSwapchainCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImageSwapchainCreateInfoKHR* ptr() { return reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this); }
+    VkImageSwapchainCreateInfoKHR const* ptr() const { return reinterpret_cast<VkImageSwapchainCreateInfoKHR const*>(this); }
+};
+struct BindImageMemorySwapchainInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSwapchainKHR swapchain;
+    uint32_t imageIndex;
+
+    BindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    BindImageMemorySwapchainInfoKHR(const BindImageMemorySwapchainInfoKHR& copy_src);
+    BindImageMemorySwapchainInfoKHR& operator=(const BindImageMemorySwapchainInfoKHR& copy_src);
+    BindImageMemorySwapchainInfoKHR();
+    ~BindImageMemorySwapchainInfoKHR();
+    void initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindImageMemorySwapchainInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkBindImageMemorySwapchainInfoKHR* ptr() { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this); }
+    VkBindImageMemorySwapchainInfoKHR const* ptr() const {
+        return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR const*>(this);
+    }
+};
+struct AcquireNextImageInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSwapchainKHR swapchain;
+    uint64_t timeout;
+    VkSemaphore semaphore;
+    VkFence fence;
+    uint32_t deviceMask;
+
+    AcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AcquireNextImageInfoKHR(const AcquireNextImageInfoKHR& copy_src);
+    AcquireNextImageInfoKHR& operator=(const AcquireNextImageInfoKHR& copy_src);
+    AcquireNextImageInfoKHR();
+    ~AcquireNextImageInfoKHR();
+    void initialize(const VkAcquireNextImageInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AcquireNextImageInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAcquireNextImageInfoKHR* ptr() { return reinterpret_cast<VkAcquireNextImageInfoKHR*>(this); }
+    VkAcquireNextImageInfoKHR const* ptr() const { return reinterpret_cast<VkAcquireNextImageInfoKHR const*>(this); }
+};
+struct DeviceGroupPresentCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
+    VkDeviceGroupPresentModeFlagsKHR modes;
+
+    DeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    DeviceGroupPresentCapabilitiesKHR(const DeviceGroupPresentCapabilitiesKHR& copy_src);
+    DeviceGroupPresentCapabilitiesKHR& operator=(const DeviceGroupPresentCapabilitiesKHR& copy_src);
+    DeviceGroupPresentCapabilitiesKHR();
+    ~DeviceGroupPresentCapabilitiesKHR();
+    void initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceGroupPresentCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupPresentCapabilitiesKHR* ptr() { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this); }
+    VkDeviceGroupPresentCapabilitiesKHR const* ptr() const {
+        return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR const*>(this);
+    }
+};
+struct DeviceGroupPresentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    const uint32_t* pDeviceMasks{};
+    VkDeviceGroupPresentModeFlagBitsKHR mode;
+
+    DeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    DeviceGroupPresentInfoKHR(const DeviceGroupPresentInfoKHR& copy_src);
+    DeviceGroupPresentInfoKHR& operator=(const DeviceGroupPresentInfoKHR& copy_src);
+    DeviceGroupPresentInfoKHR();
+    ~DeviceGroupPresentInfoKHR();
+    void initialize(const VkDeviceGroupPresentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceGroupPresentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupPresentInfoKHR* ptr() { return reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this); }
+    VkDeviceGroupPresentInfoKHR const* ptr() const { return reinterpret_cast<VkDeviceGroupPresentInfoKHR const*>(this); }
+};
+struct DeviceGroupSwapchainCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceGroupPresentModeFlagsKHR modes;
+
+    DeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    DeviceGroupSwapchainCreateInfoKHR(const DeviceGroupSwapchainCreateInfoKHR& copy_src);
+    DeviceGroupSwapchainCreateInfoKHR& operator=(const DeviceGroupSwapchainCreateInfoKHR& copy_src);
+    DeviceGroupSwapchainCreateInfoKHR();
+    ~DeviceGroupSwapchainCreateInfoKHR();
+    void initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceGroupSwapchainCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupSwapchainCreateInfoKHR* ptr() { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this); }
+    VkDeviceGroupSwapchainCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR const*>(this);
+    }
+};
+struct DisplayModeCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDisplayModeCreateFlagsKHR flags;
+    VkDisplayModeParametersKHR parameters;
+
+    DisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DisplayModeCreateInfoKHR(const DisplayModeCreateInfoKHR& copy_src);
+    DisplayModeCreateInfoKHR& operator=(const DisplayModeCreateInfoKHR& copy_src);
+    DisplayModeCreateInfoKHR();
+    ~DisplayModeCreateInfoKHR();
+    void initialize(const VkDisplayModeCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplayModeCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayModeCreateInfoKHR* ptr() { return reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this); }
+    VkDisplayModeCreateInfoKHR const* ptr() const { return reinterpret_cast<VkDisplayModeCreateInfoKHR const*>(this); }
+};
+struct DisplayPropertiesKHR {
+    VkDisplayKHR display;
+    const char* displayName{};
+    VkExtent2D physicalDimensions;
+    VkExtent2D physicalResolution;
+    VkSurfaceTransformFlagsKHR supportedTransforms;
+    VkBool32 planeReorderPossible;
+    VkBool32 persistentContent;
+
+    DisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    DisplayPropertiesKHR(const DisplayPropertiesKHR& copy_src);
+    DisplayPropertiesKHR& operator=(const DisplayPropertiesKHR& copy_src);
+    DisplayPropertiesKHR();
+    ~DisplayPropertiesKHR();
+    void initialize(const VkDisplayPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplayPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayPropertiesKHR* ptr() { return reinterpret_cast<VkDisplayPropertiesKHR*>(this); }
+    VkDisplayPropertiesKHR const* ptr() const { return reinterpret_cast<VkDisplayPropertiesKHR const*>(this); }
+};
+struct DisplaySurfaceCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDisplaySurfaceCreateFlagsKHR flags;
+    VkDisplayModeKHR displayMode;
+    uint32_t planeIndex;
+    uint32_t planeStackIndex;
+    VkSurfaceTransformFlagBitsKHR transform;
+    float globalAlpha;
+    VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
+    VkExtent2D imageExtent;
+
+    DisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    DisplaySurfaceCreateInfoKHR(const DisplaySurfaceCreateInfoKHR& copy_src);
+    DisplaySurfaceCreateInfoKHR& operator=(const DisplaySurfaceCreateInfoKHR& copy_src);
+    DisplaySurfaceCreateInfoKHR();
+    ~DisplaySurfaceCreateInfoKHR();
+    void initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplaySurfaceCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplaySurfaceCreateInfoKHR* ptr() { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this); }
+    VkDisplaySurfaceCreateInfoKHR const* ptr() const { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR const*>(this); }
+};
+struct DisplayPresentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRect2D srcRect;
+    VkRect2D dstRect;
+    VkBool32 persistent;
+
+    DisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DisplayPresentInfoKHR(const DisplayPresentInfoKHR& copy_src);
+    DisplayPresentInfoKHR& operator=(const DisplayPresentInfoKHR& copy_src);
+    DisplayPresentInfoKHR();
+    ~DisplayPresentInfoKHR();
+    void initialize(const VkDisplayPresentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplayPresentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayPresentInfoKHR* ptr() { return reinterpret_cast<VkDisplayPresentInfoKHR*>(this); }
+    VkDisplayPresentInfoKHR const* ptr() const { return reinterpret_cast<VkDisplayPresentInfoKHR const*>(this); }
+};
+struct QueueFamilyQueryResultStatusPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 queryResultStatusSupport;
+
+    QueueFamilyQueryResultStatusPropertiesKHR(const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    QueueFamilyQueryResultStatusPropertiesKHR(const QueueFamilyQueryResultStatusPropertiesKHR& copy_src);
+    QueueFamilyQueryResultStatusPropertiesKHR& operator=(const QueueFamilyQueryResultStatusPropertiesKHR& copy_src);
+    QueueFamilyQueryResultStatusPropertiesKHR();
+    ~QueueFamilyQueryResultStatusPropertiesKHR();
+    void initialize(const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const QueueFamilyQueryResultStatusPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyQueryResultStatusPropertiesKHR* ptr() {
+        return reinterpret_cast<VkQueueFamilyQueryResultStatusPropertiesKHR*>(this);
+    }
+    VkQueueFamilyQueryResultStatusPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkQueueFamilyQueryResultStatusPropertiesKHR const*>(this);
+    }
+};
+struct QueueFamilyVideoPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoCodecOperationFlagsKHR videoCodecOperations;
+
+    QueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    QueueFamilyVideoPropertiesKHR(const QueueFamilyVideoPropertiesKHR& copy_src);
+    QueueFamilyVideoPropertiesKHR& operator=(const QueueFamilyVideoPropertiesKHR& copy_src);
+    QueueFamilyVideoPropertiesKHR();
+    ~QueueFamilyVideoPropertiesKHR();
+    void initialize(const VkQueueFamilyVideoPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const QueueFamilyVideoPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyVideoPropertiesKHR* ptr() { return reinterpret_cast<VkQueueFamilyVideoPropertiesKHR*>(this); }
+    VkQueueFamilyVideoPropertiesKHR const* ptr() const { return reinterpret_cast<VkQueueFamilyVideoPropertiesKHR const*>(this); }
+};
+struct VideoProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
+    VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
+    VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
+    VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
+
+    VideoProfileInfoKHR(const VkVideoProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoProfileInfoKHR(const VideoProfileInfoKHR& copy_src);
+    VideoProfileInfoKHR& operator=(const VideoProfileInfoKHR& copy_src);
+    VideoProfileInfoKHR();
+    ~VideoProfileInfoKHR();
+    void initialize(const VkVideoProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoProfileInfoKHR*>(this); }
+    VkVideoProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoProfileInfoKHR const*>(this); }
+};
+struct VideoProfileListInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t profileCount;
+    VideoProfileInfoKHR* pProfiles{};
+
+    VideoProfileListInfoKHR(const VkVideoProfileListInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoProfileListInfoKHR(const VideoProfileListInfoKHR& copy_src);
+    VideoProfileListInfoKHR& operator=(const VideoProfileListInfoKHR& copy_src);
+    VideoProfileListInfoKHR();
+    ~VideoProfileListInfoKHR();
+    void initialize(const VkVideoProfileListInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoProfileListInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoProfileListInfoKHR* ptr() { return reinterpret_cast<VkVideoProfileListInfoKHR*>(this); }
+    VkVideoProfileListInfoKHR const* ptr() const { return reinterpret_cast<VkVideoProfileListInfoKHR const*>(this); }
+};
+struct VideoCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoCapabilityFlagsKHR flags;
+    VkDeviceSize minBitstreamBufferOffsetAlignment;
+    VkDeviceSize minBitstreamBufferSizeAlignment;
+    VkExtent2D pictureAccessGranularity;
+    VkExtent2D minCodedExtent;
+    VkExtent2D maxCodedExtent;
+    uint32_t maxDpbSlots;
+    uint32_t maxActiveReferencePictures;
+    VkExtensionProperties stdHeaderVersion;
+
+    VideoCapabilitiesKHR(const VkVideoCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoCapabilitiesKHR(const VideoCapabilitiesKHR& copy_src);
+    VideoCapabilitiesKHR& operator=(const VideoCapabilitiesKHR& copy_src);
+    VideoCapabilitiesKHR();
+    ~VideoCapabilitiesKHR();
+    void initialize(const VkVideoCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoCapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoCapabilitiesKHR*>(this); }
+    VkVideoCapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoCapabilitiesKHR const*>(this); }
+};
+struct PhysicalDeviceVideoFormatInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageUsageFlags imageUsage;
+
+    PhysicalDeviceVideoFormatInfoKHR(const VkPhysicalDeviceVideoFormatInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    PhysicalDeviceVideoFormatInfoKHR(const PhysicalDeviceVideoFormatInfoKHR& copy_src);
+    PhysicalDeviceVideoFormatInfoKHR& operator=(const PhysicalDeviceVideoFormatInfoKHR& copy_src);
+    PhysicalDeviceVideoFormatInfoKHR();
+    ~PhysicalDeviceVideoFormatInfoKHR();
+    void initialize(const VkPhysicalDeviceVideoFormatInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVideoFormatInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVideoFormatInfoKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceVideoFormatInfoKHR*>(this); }
+    VkPhysicalDeviceVideoFormatInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVideoFormatInfoKHR const*>(this);
+    }
+};
+struct VideoFormatPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat format;
+    VkComponentMapping componentMapping;
+    VkImageCreateFlags imageCreateFlags;
+    VkImageType imageType;
+    VkImageTiling imageTiling;
+    VkImageUsageFlags imageUsageFlags;
+
+    VideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoFormatPropertiesKHR(const VideoFormatPropertiesKHR& copy_src);
+    VideoFormatPropertiesKHR& operator=(const VideoFormatPropertiesKHR& copy_src);
+    VideoFormatPropertiesKHR();
+    ~VideoFormatPropertiesKHR();
+    void initialize(const VkVideoFormatPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoFormatPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoFormatPropertiesKHR* ptr() { return reinterpret_cast<VkVideoFormatPropertiesKHR*>(this); }
+    VkVideoFormatPropertiesKHR const* ptr() const { return reinterpret_cast<VkVideoFormatPropertiesKHR const*>(this); }
+};
+struct VideoPictureResourceInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkOffset2D codedOffset;
+    VkExtent2D codedExtent;
+    uint32_t baseArrayLayer;
+    VkImageView imageViewBinding;
+
+    VideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    VideoPictureResourceInfoKHR(const VideoPictureResourceInfoKHR& copy_src);
+    VideoPictureResourceInfoKHR& operator=(const VideoPictureResourceInfoKHR& copy_src);
+    VideoPictureResourceInfoKHR();
+    ~VideoPictureResourceInfoKHR();
+    void initialize(const VkVideoPictureResourceInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoPictureResourceInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoPictureResourceInfoKHR* ptr() { return reinterpret_cast<VkVideoPictureResourceInfoKHR*>(this); }
+    VkVideoPictureResourceInfoKHR const* ptr() const { return reinterpret_cast<VkVideoPictureResourceInfoKHR const*>(this); }
+};
+struct VideoReferenceSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    int32_t slotIndex;
+    VideoPictureResourceInfoKHR* pPictureResource{};
+
+    VideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    VideoReferenceSlotInfoKHR(const VideoReferenceSlotInfoKHR& copy_src);
+    VideoReferenceSlotInfoKHR& operator=(const VideoReferenceSlotInfoKHR& copy_src);
+    VideoReferenceSlotInfoKHR();
+    ~VideoReferenceSlotInfoKHR();
+    void initialize(const VkVideoReferenceSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoReferenceSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoReferenceSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoReferenceSlotInfoKHR*>(this); }
+    VkVideoReferenceSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoReferenceSlotInfoKHR const*>(this); }
+};
+struct VideoSessionMemoryRequirementsKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryBindIndex;
+    VkMemoryRequirements memoryRequirements;
+
+    VideoSessionMemoryRequirementsKHR(const VkVideoSessionMemoryRequirementsKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    VideoSessionMemoryRequirementsKHR(const VideoSessionMemoryRequirementsKHR& copy_src);
+    VideoSessionMemoryRequirementsKHR& operator=(const VideoSessionMemoryRequirementsKHR& copy_src);
+    VideoSessionMemoryRequirementsKHR();
+    ~VideoSessionMemoryRequirementsKHR();
+    void initialize(const VkVideoSessionMemoryRequirementsKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoSessionMemoryRequirementsKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoSessionMemoryRequirementsKHR* ptr() { return reinterpret_cast<VkVideoSessionMemoryRequirementsKHR*>(this); }
+    VkVideoSessionMemoryRequirementsKHR const* ptr() const {
+        return reinterpret_cast<VkVideoSessionMemoryRequirementsKHR const*>(this);
+    }
+};
+struct BindVideoSessionMemoryInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t memoryBindIndex;
+    VkDeviceMemory memory;
+    VkDeviceSize memoryOffset;
+    VkDeviceSize memorySize;
+
+    BindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    BindVideoSessionMemoryInfoKHR(const BindVideoSessionMemoryInfoKHR& copy_src);
+    BindVideoSessionMemoryInfoKHR& operator=(const BindVideoSessionMemoryInfoKHR& copy_src);
+    BindVideoSessionMemoryInfoKHR();
+    ~BindVideoSessionMemoryInfoKHR();
+    void initialize(const VkBindVideoSessionMemoryInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindVideoSessionMemoryInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkBindVideoSessionMemoryInfoKHR* ptr() { return reinterpret_cast<VkBindVideoSessionMemoryInfoKHR*>(this); }
+    VkBindVideoSessionMemoryInfoKHR const* ptr() const { return reinterpret_cast<VkBindVideoSessionMemoryInfoKHR const*>(this); }
+};
+struct VideoSessionCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t queueFamilyIndex;
+    VkVideoSessionCreateFlagsKHR flags;
+    VideoProfileInfoKHR* pVideoProfile{};
+    VkFormat pictureFormat;
+    VkExtent2D maxCodedExtent;
+    VkFormat referencePictureFormat;
+    uint32_t maxDpbSlots;
+    uint32_t maxActiveReferencePictures;
+    const VkExtensionProperties* pStdHeaderVersion{};
+
+    VideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    VideoSessionCreateInfoKHR(const VideoSessionCreateInfoKHR& copy_src);
+    VideoSessionCreateInfoKHR& operator=(const VideoSessionCreateInfoKHR& copy_src);
+    VideoSessionCreateInfoKHR();
+    ~VideoSessionCreateInfoKHR();
+    void initialize(const VkVideoSessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoSessionCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoSessionCreateInfoKHR* ptr() { return reinterpret_cast<VkVideoSessionCreateInfoKHR*>(this); }
+    VkVideoSessionCreateInfoKHR const* ptr() const { return reinterpret_cast<VkVideoSessionCreateInfoKHR const*>(this); }
+};
+struct VideoSessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoSessionParametersCreateFlagsKHR flags;
+    VkVideoSessionParametersKHR videoSessionParametersTemplate;
+    VkVideoSessionKHR videoSession;
+
+    VideoSessionParametersCreateInfoKHR(const VkVideoSessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    VideoSessionParametersCreateInfoKHR(const VideoSessionParametersCreateInfoKHR& copy_src);
+    VideoSessionParametersCreateInfoKHR& operator=(const VideoSessionParametersCreateInfoKHR& copy_src);
+    VideoSessionParametersCreateInfoKHR();
+    ~VideoSessionParametersCreateInfoKHR();
+    void initialize(const VkVideoSessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoSessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoSessionParametersCreateInfoKHR* ptr() { return reinterpret_cast<VkVideoSessionParametersCreateInfoKHR*>(this); }
+    VkVideoSessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoSessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct VideoSessionParametersUpdateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t updateSequenceCount;
+
+    VideoSessionParametersUpdateInfoKHR(const VkVideoSessionParametersUpdateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    VideoSessionParametersUpdateInfoKHR(const VideoSessionParametersUpdateInfoKHR& copy_src);
+    VideoSessionParametersUpdateInfoKHR& operator=(const VideoSessionParametersUpdateInfoKHR& copy_src);
+    VideoSessionParametersUpdateInfoKHR();
+    ~VideoSessionParametersUpdateInfoKHR();
+    void initialize(const VkVideoSessionParametersUpdateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoSessionParametersUpdateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoSessionParametersUpdateInfoKHR* ptr() { return reinterpret_cast<VkVideoSessionParametersUpdateInfoKHR*>(this); }
+    VkVideoSessionParametersUpdateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoSessionParametersUpdateInfoKHR const*>(this);
+    }
+};
+struct VideoBeginCodingInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoBeginCodingFlagsKHR flags;
+    VkVideoSessionKHR videoSession;
+    VkVideoSessionParametersKHR videoSessionParameters;
+    uint32_t referenceSlotCount;
+    VideoReferenceSlotInfoKHR* pReferenceSlots{};
+
+    VideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoBeginCodingInfoKHR(const VideoBeginCodingInfoKHR& copy_src);
+    VideoBeginCodingInfoKHR& operator=(const VideoBeginCodingInfoKHR& copy_src);
+    VideoBeginCodingInfoKHR();
+    ~VideoBeginCodingInfoKHR();
+    void initialize(const VkVideoBeginCodingInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoBeginCodingInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoBeginCodingInfoKHR* ptr() { return reinterpret_cast<VkVideoBeginCodingInfoKHR*>(this); }
+    VkVideoBeginCodingInfoKHR const* ptr() const { return reinterpret_cast<VkVideoBeginCodingInfoKHR const*>(this); }
+};
+struct VideoEndCodingInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEndCodingFlagsKHR flags;
+
+    VideoEndCodingInfoKHR(const VkVideoEndCodingInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEndCodingInfoKHR(const VideoEndCodingInfoKHR& copy_src);
+    VideoEndCodingInfoKHR& operator=(const VideoEndCodingInfoKHR& copy_src);
+    VideoEndCodingInfoKHR();
+    ~VideoEndCodingInfoKHR();
+    void initialize(const VkVideoEndCodingInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEndCodingInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEndCodingInfoKHR* ptr() { return reinterpret_cast<VkVideoEndCodingInfoKHR*>(this); }
+    VkVideoEndCodingInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEndCodingInfoKHR const*>(this); }
+};
+struct VideoCodingControlInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoCodingControlFlagsKHR flags;
+
+    VideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    VideoCodingControlInfoKHR(const VideoCodingControlInfoKHR& copy_src);
+    VideoCodingControlInfoKHR& operator=(const VideoCodingControlInfoKHR& copy_src);
+    VideoCodingControlInfoKHR();
+    ~VideoCodingControlInfoKHR();
+    void initialize(const VkVideoCodingControlInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoCodingControlInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoCodingControlInfoKHR* ptr() { return reinterpret_cast<VkVideoCodingControlInfoKHR*>(this); }
+    VkVideoCodingControlInfoKHR const* ptr() const { return reinterpret_cast<VkVideoCodingControlInfoKHR const*>(this); }
+};
+struct VideoDecodeCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoDecodeCapabilityFlagsKHR flags;
+
+    VideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    VideoDecodeCapabilitiesKHR(const VideoDecodeCapabilitiesKHR& copy_src);
+    VideoDecodeCapabilitiesKHR& operator=(const VideoDecodeCapabilitiesKHR& copy_src);
+    VideoDecodeCapabilitiesKHR();
+    ~VideoDecodeCapabilitiesKHR();
+    void initialize(const VkVideoDecodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeCapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoDecodeCapabilitiesKHR*>(this); }
+    VkVideoDecodeCapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeCapabilitiesKHR const*>(this); }
+};
+struct VideoDecodeUsageInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoDecodeUsageFlagsKHR videoUsageHints;
+
+    VideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoDecodeUsageInfoKHR(const VideoDecodeUsageInfoKHR& copy_src);
+    VideoDecodeUsageInfoKHR& operator=(const VideoDecodeUsageInfoKHR& copy_src);
+    VideoDecodeUsageInfoKHR();
+    ~VideoDecodeUsageInfoKHR();
+    void initialize(const VkVideoDecodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeUsageInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeUsageInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeUsageInfoKHR*>(this); }
+    VkVideoDecodeUsageInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeUsageInfoKHR const*>(this); }
+};
+struct VideoDecodeInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoDecodeFlagsKHR flags;
+    VkBuffer srcBuffer;
+    VkDeviceSize srcBufferOffset;
+    VkDeviceSize srcBufferRange;
+    VideoPictureResourceInfoKHR dstPictureResource;
+    VideoReferenceSlotInfoKHR* pSetupReferenceSlot{};
+    uint32_t referenceSlotCount;
+    VideoReferenceSlotInfoKHR* pReferenceSlots{};
+
+    VideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoDecodeInfoKHR(const VideoDecodeInfoKHR& copy_src);
+    VideoDecodeInfoKHR& operator=(const VideoDecodeInfoKHR& copy_src);
+    VideoDecodeInfoKHR();
+    ~VideoDecodeInfoKHR();
+    void initialize(const VkVideoDecodeInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeInfoKHR*>(this); }
+    VkVideoDecodeInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeInfoKHR const*>(this); }
+};
+struct VideoEncodeH264CapabilitiesKHR {
+    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;
+
+    VideoEncodeH264CapabilitiesKHR(const VkVideoEncodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    VideoEncodeH264CapabilitiesKHR(const VideoEncodeH264CapabilitiesKHR& copy_src);
+    VideoEncodeH264CapabilitiesKHR& operator=(const VideoEncodeH264CapabilitiesKHR& copy_src);
+    VideoEncodeH264CapabilitiesKHR();
+    ~VideoEncodeH264CapabilitiesKHR();
+    void initialize(const VkVideoEncodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264CapabilitiesKHR*>(this); }
+    VkVideoEncodeH264CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH264CapabilitiesKHR const*>(this); }
+};
+struct VideoEncodeH264QualityLevelPropertiesKHR {
+    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;
+
+    VideoEncodeH264QualityLevelPropertiesKHR(const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH264QualityLevelPropertiesKHR(const VideoEncodeH264QualityLevelPropertiesKHR& copy_src);
+    VideoEncodeH264QualityLevelPropertiesKHR& operator=(const VideoEncodeH264QualityLevelPropertiesKHR& copy_src);
+    VideoEncodeH264QualityLevelPropertiesKHR();
+    ~VideoEncodeH264QualityLevelPropertiesKHR();
+    void initialize(const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264QualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264QualityLevelPropertiesKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH264QualityLevelPropertiesKHR*>(this);
+    }
+    VkVideoEncodeH264QualityLevelPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264QualityLevelPropertiesKHR const*>(this);
+    }
+};
+struct VideoEncodeH264SessionCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useMaxLevelIdc;
+    StdVideoH264LevelIdc maxLevelIdc;
+
+    VideoEncodeH264SessionCreateInfoKHR(const VkVideoEncodeH264SessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    VideoEncodeH264SessionCreateInfoKHR(const VideoEncodeH264SessionCreateInfoKHR& copy_src);
+    VideoEncodeH264SessionCreateInfoKHR& operator=(const VideoEncodeH264SessionCreateInfoKHR& copy_src);
+    VideoEncodeH264SessionCreateInfoKHR();
+    ~VideoEncodeH264SessionCreateInfoKHR();
+    void initialize(const VkVideoEncodeH264SessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264SessionCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264SessionCreateInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264SessionCreateInfoKHR*>(this); }
+    VkVideoEncodeH264SessionCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264SessionCreateInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH264SessionParametersAddInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stdSPSCount;
+    const StdVideoH264SequenceParameterSet* pStdSPSs{};
+    uint32_t stdPPSCount;
+    const StdVideoH264PictureParameterSet* pStdPPSs{};
+
+    VideoEncodeH264SessionParametersAddInfoKHR(const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH264SessionParametersAddInfoKHR(const VideoEncodeH264SessionParametersAddInfoKHR& copy_src);
+    VideoEncodeH264SessionParametersAddInfoKHR& operator=(const VideoEncodeH264SessionParametersAddInfoKHR& copy_src);
+    VideoEncodeH264SessionParametersAddInfoKHR();
+    ~VideoEncodeH264SessionParametersAddInfoKHR();
+    void initialize(const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264SessionParametersAddInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoKHR*>(this);
+    }
+    VkVideoEncodeH264SessionParametersAddInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH264SessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxStdSPSCount;
+    uint32_t maxStdPPSCount;
+    VideoEncodeH264SessionParametersAddInfoKHR* pParametersAddInfo{};
+
+    VideoEncodeH264SessionParametersCreateInfoKHR(const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH264SessionParametersCreateInfoKHR(const VideoEncodeH264SessionParametersCreateInfoKHR& copy_src);
+    VideoEncodeH264SessionParametersCreateInfoKHR& operator=(const VideoEncodeH264SessionParametersCreateInfoKHR& copy_src);
+    VideoEncodeH264SessionParametersCreateInfoKHR();
+    ~VideoEncodeH264SessionParametersCreateInfoKHR();
+    void initialize(const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264SessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoEncodeH264SessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH264SessionParametersGetInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 writeStdSPS;
+    VkBool32 writeStdPPS;
+    uint32_t stdSPSId;
+    uint32_t stdPPSId;
+
+    VideoEncodeH264SessionParametersGetInfoKHR(const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH264SessionParametersGetInfoKHR(const VideoEncodeH264SessionParametersGetInfoKHR& copy_src);
+    VideoEncodeH264SessionParametersGetInfoKHR& operator=(const VideoEncodeH264SessionParametersGetInfoKHR& copy_src);
+    VideoEncodeH264SessionParametersGetInfoKHR();
+    ~VideoEncodeH264SessionParametersGetInfoKHR();
+    void initialize(const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264SessionParametersGetInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264SessionParametersGetInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersGetInfoKHR*>(this);
+    }
+    VkVideoEncodeH264SessionParametersGetInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersGetInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH264SessionParametersFeedbackInfoKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hasStdSPSOverrides;
+    VkBool32 hasStdPPSOverrides;
+
+    VideoEncodeH264SessionParametersFeedbackInfoKHR(const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH264SessionParametersFeedbackInfoKHR(const VideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src);
+    VideoEncodeH264SessionParametersFeedbackInfoKHR& operator=(const VideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src);
+    VideoEncodeH264SessionParametersFeedbackInfoKHR();
+    ~VideoEncodeH264SessionParametersFeedbackInfoKHR();
+    void initialize(const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264SessionParametersFeedbackInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264SessionParametersFeedbackInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersFeedbackInfoKHR*>(this);
+    }
+    VkVideoEncodeH264SessionParametersFeedbackInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersFeedbackInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH264NaluSliceInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    int32_t constantQp;
+    const StdVideoEncodeH264SliceHeader* pStdSliceHeader{};
+
+    VideoEncodeH264NaluSliceInfoKHR(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    VideoEncodeH264NaluSliceInfoKHR(const VideoEncodeH264NaluSliceInfoKHR& copy_src);
+    VideoEncodeH264NaluSliceInfoKHR& operator=(const VideoEncodeH264NaluSliceInfoKHR& copy_src);
+    VideoEncodeH264NaluSliceInfoKHR();
+    ~VideoEncodeH264NaluSliceInfoKHR();
+    void initialize(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264NaluSliceInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264NaluSliceInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264NaluSliceInfoKHR*>(this); }
+    VkVideoEncodeH264NaluSliceInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264NaluSliceInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH264PictureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t naluSliceEntryCount;
+    VideoEncodeH264NaluSliceInfoKHR* pNaluSliceEntries{};
+    const StdVideoEncodeH264PictureInfo* pStdPictureInfo{};
+    VkBool32 generatePrefixNalu;
+
+    VideoEncodeH264PictureInfoKHR(const VkVideoEncodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoEncodeH264PictureInfoKHR(const VideoEncodeH264PictureInfoKHR& copy_src);
+    VideoEncodeH264PictureInfoKHR& operator=(const VideoEncodeH264PictureInfoKHR& copy_src);
+    VideoEncodeH264PictureInfoKHR();
+    ~VideoEncodeH264PictureInfoKHR();
+    void initialize(const VkVideoEncodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264PictureInfoKHR*>(this); }
+    VkVideoEncodeH264PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH264PictureInfoKHR const*>(this); }
+};
+struct VideoEncodeH264DpbSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo{};
+
+    VideoEncodeH264DpbSlotInfoKHR(const VkVideoEncodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoEncodeH264DpbSlotInfoKHR(const VideoEncodeH264DpbSlotInfoKHR& copy_src);
+    VideoEncodeH264DpbSlotInfoKHR& operator=(const VideoEncodeH264DpbSlotInfoKHR& copy_src);
+    VideoEncodeH264DpbSlotInfoKHR();
+    ~VideoEncodeH264DpbSlotInfoKHR();
+    void initialize(const VkVideoEncodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264DpbSlotInfoKHR*>(this); }
+    VkVideoEncodeH264DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH264DpbSlotInfoKHR const*>(this); }
+};
+struct VideoEncodeH264ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoH264ProfileIdc stdProfileIdc;
+
+    VideoEncodeH264ProfileInfoKHR(const VkVideoEncodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoEncodeH264ProfileInfoKHR(const VideoEncodeH264ProfileInfoKHR& copy_src);
+    VideoEncodeH264ProfileInfoKHR& operator=(const VideoEncodeH264ProfileInfoKHR& copy_src);
+    VideoEncodeH264ProfileInfoKHR();
+    ~VideoEncodeH264ProfileInfoKHR();
+    void initialize(const VkVideoEncodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264ProfileInfoKHR*>(this); }
+    VkVideoEncodeH264ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH264ProfileInfoKHR const*>(this); }
+};
+struct VideoEncodeH264RateControlInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeH264RateControlFlagsKHR flags;
+    uint32_t gopFrameCount;
+    uint32_t idrPeriod;
+    uint32_t consecutiveBFrameCount;
+    uint32_t temporalLayerCount;
+
+    VideoEncodeH264RateControlInfoKHR(const VkVideoEncodeH264RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    VideoEncodeH264RateControlInfoKHR(const VideoEncodeH264RateControlInfoKHR& copy_src);
+    VideoEncodeH264RateControlInfoKHR& operator=(const VideoEncodeH264RateControlInfoKHR& copy_src);
+    VideoEncodeH264RateControlInfoKHR();
+    ~VideoEncodeH264RateControlInfoKHR();
+    void initialize(const VkVideoEncodeH264RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264RateControlInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264RateControlInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264RateControlInfoKHR*>(this); }
+    VkVideoEncodeH264RateControlInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264RateControlInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH264RateControlLayerInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useMinQp;
+    VkVideoEncodeH264QpKHR minQp;
+    VkBool32 useMaxQp;
+    VkVideoEncodeH264QpKHR maxQp;
+    VkBool32 useMaxFrameSize;
+    VkVideoEncodeH264FrameSizeKHR maxFrameSize;
+
+    VideoEncodeH264RateControlLayerInfoKHR(const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH264RateControlLayerInfoKHR(const VideoEncodeH264RateControlLayerInfoKHR& copy_src);
+    VideoEncodeH264RateControlLayerInfoKHR& operator=(const VideoEncodeH264RateControlLayerInfoKHR& copy_src);
+    VideoEncodeH264RateControlLayerInfoKHR();
+    ~VideoEncodeH264RateControlLayerInfoKHR();
+    void initialize(const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264RateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264RateControlLayerInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoKHR*>(this); }
+    VkVideoEncodeH264RateControlLayerInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH264GopRemainingFrameInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useGopRemainingFrames;
+    uint32_t gopRemainingI;
+    uint32_t gopRemainingP;
+    uint32_t gopRemainingB;
+
+    VideoEncodeH264GopRemainingFrameInfoKHR(const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH264GopRemainingFrameInfoKHR(const VideoEncodeH264GopRemainingFrameInfoKHR& copy_src);
+    VideoEncodeH264GopRemainingFrameInfoKHR& operator=(const VideoEncodeH264GopRemainingFrameInfoKHR& copy_src);
+    VideoEncodeH264GopRemainingFrameInfoKHR();
+    ~VideoEncodeH264GopRemainingFrameInfoKHR();
+    void initialize(const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH264GopRemainingFrameInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264GopRemainingFrameInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264GopRemainingFrameInfoKHR*>(this); }
+    VkVideoEncodeH264GopRemainingFrameInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264GopRemainingFrameInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH265CapabilitiesKHR {
+    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;
+
+    VideoEncodeH265CapabilitiesKHR(const VkVideoEncodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    VideoEncodeH265CapabilitiesKHR(const VideoEncodeH265CapabilitiesKHR& copy_src);
+    VideoEncodeH265CapabilitiesKHR& operator=(const VideoEncodeH265CapabilitiesKHR& copy_src);
+    VideoEncodeH265CapabilitiesKHR();
+    ~VideoEncodeH265CapabilitiesKHR();
+    void initialize(const VkVideoEncodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265CapabilitiesKHR*>(this); }
+    VkVideoEncodeH265CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH265CapabilitiesKHR const*>(this); }
+};
+struct VideoEncodeH265SessionCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useMaxLevelIdc;
+    StdVideoH265LevelIdc maxLevelIdc;
+
+    VideoEncodeH265SessionCreateInfoKHR(const VkVideoEncodeH265SessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    VideoEncodeH265SessionCreateInfoKHR(const VideoEncodeH265SessionCreateInfoKHR& copy_src);
+    VideoEncodeH265SessionCreateInfoKHR& operator=(const VideoEncodeH265SessionCreateInfoKHR& copy_src);
+    VideoEncodeH265SessionCreateInfoKHR();
+    ~VideoEncodeH265SessionCreateInfoKHR();
+    void initialize(const VkVideoEncodeH265SessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265SessionCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265SessionCreateInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265SessionCreateInfoKHR*>(this); }
+    VkVideoEncodeH265SessionCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265SessionCreateInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH265QualityLevelPropertiesKHR {
+    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;
+
+    VideoEncodeH265QualityLevelPropertiesKHR(const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH265QualityLevelPropertiesKHR(const VideoEncodeH265QualityLevelPropertiesKHR& copy_src);
+    VideoEncodeH265QualityLevelPropertiesKHR& operator=(const VideoEncodeH265QualityLevelPropertiesKHR& copy_src);
+    VideoEncodeH265QualityLevelPropertiesKHR();
+    ~VideoEncodeH265QualityLevelPropertiesKHR();
+    void initialize(const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265QualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265QualityLevelPropertiesKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH265QualityLevelPropertiesKHR*>(this);
+    }
+    VkVideoEncodeH265QualityLevelPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265QualityLevelPropertiesKHR const*>(this);
+    }
+};
+struct VideoEncodeH265SessionParametersAddInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stdVPSCount;
+    const StdVideoH265VideoParameterSet* pStdVPSs{};
+    uint32_t stdSPSCount;
+    const StdVideoH265SequenceParameterSet* pStdSPSs{};
+    uint32_t stdPPSCount;
+    const StdVideoH265PictureParameterSet* pStdPPSs{};
+
+    VideoEncodeH265SessionParametersAddInfoKHR(const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH265SessionParametersAddInfoKHR(const VideoEncodeH265SessionParametersAddInfoKHR& copy_src);
+    VideoEncodeH265SessionParametersAddInfoKHR& operator=(const VideoEncodeH265SessionParametersAddInfoKHR& copy_src);
+    VideoEncodeH265SessionParametersAddInfoKHR();
+    ~VideoEncodeH265SessionParametersAddInfoKHR();
+    void initialize(const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265SessionParametersAddInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoKHR*>(this);
+    }
+    VkVideoEncodeH265SessionParametersAddInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH265SessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxStdVPSCount;
+    uint32_t maxStdSPSCount;
+    uint32_t maxStdPPSCount;
+    VideoEncodeH265SessionParametersAddInfoKHR* pParametersAddInfo{};
+
+    VideoEncodeH265SessionParametersCreateInfoKHR(const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH265SessionParametersCreateInfoKHR(const VideoEncodeH265SessionParametersCreateInfoKHR& copy_src);
+    VideoEncodeH265SessionParametersCreateInfoKHR& operator=(const VideoEncodeH265SessionParametersCreateInfoKHR& copy_src);
+    VideoEncodeH265SessionParametersCreateInfoKHR();
+    ~VideoEncodeH265SessionParametersCreateInfoKHR();
+    void initialize(const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265SessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoEncodeH265SessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH265SessionParametersGetInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 writeStdVPS;
+    VkBool32 writeStdSPS;
+    VkBool32 writeStdPPS;
+    uint32_t stdVPSId;
+    uint32_t stdSPSId;
+    uint32_t stdPPSId;
+
+    VideoEncodeH265SessionParametersGetInfoKHR(const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH265SessionParametersGetInfoKHR(const VideoEncodeH265SessionParametersGetInfoKHR& copy_src);
+    VideoEncodeH265SessionParametersGetInfoKHR& operator=(const VideoEncodeH265SessionParametersGetInfoKHR& copy_src);
+    VideoEncodeH265SessionParametersGetInfoKHR();
+    ~VideoEncodeH265SessionParametersGetInfoKHR();
+    void initialize(const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265SessionParametersGetInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265SessionParametersGetInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersGetInfoKHR*>(this);
+    }
+    VkVideoEncodeH265SessionParametersGetInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersGetInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH265SessionParametersFeedbackInfoKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hasStdVPSOverrides;
+    VkBool32 hasStdSPSOverrides;
+    VkBool32 hasStdPPSOverrides;
+
+    VideoEncodeH265SessionParametersFeedbackInfoKHR(const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH265SessionParametersFeedbackInfoKHR(const VideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src);
+    VideoEncodeH265SessionParametersFeedbackInfoKHR& operator=(const VideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src);
+    VideoEncodeH265SessionParametersFeedbackInfoKHR();
+    ~VideoEncodeH265SessionParametersFeedbackInfoKHR();
+    void initialize(const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265SessionParametersFeedbackInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265SessionParametersFeedbackInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersFeedbackInfoKHR*>(this);
+    }
+    VkVideoEncodeH265SessionParametersFeedbackInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersFeedbackInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH265NaluSliceSegmentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    int32_t constantQp;
+    const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader{};
+
+    VideoEncodeH265NaluSliceSegmentInfoKHR(const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH265NaluSliceSegmentInfoKHR(const VideoEncodeH265NaluSliceSegmentInfoKHR& copy_src);
+    VideoEncodeH265NaluSliceSegmentInfoKHR& operator=(const VideoEncodeH265NaluSliceSegmentInfoKHR& copy_src);
+    VideoEncodeH265NaluSliceSegmentInfoKHR();
+    ~VideoEncodeH265NaluSliceSegmentInfoKHR();
+    void initialize(const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265NaluSliceSegmentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265NaluSliceSegmentInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265NaluSliceSegmentInfoKHR*>(this); }
+    VkVideoEncodeH265NaluSliceSegmentInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265NaluSliceSegmentInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH265PictureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t naluSliceSegmentEntryCount;
+    VideoEncodeH265NaluSliceSegmentInfoKHR* pNaluSliceSegmentEntries{};
+    const StdVideoEncodeH265PictureInfo* pStdPictureInfo{};
+
+    VideoEncodeH265PictureInfoKHR(const VkVideoEncodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoEncodeH265PictureInfoKHR(const VideoEncodeH265PictureInfoKHR& copy_src);
+    VideoEncodeH265PictureInfoKHR& operator=(const VideoEncodeH265PictureInfoKHR& copy_src);
+    VideoEncodeH265PictureInfoKHR();
+    ~VideoEncodeH265PictureInfoKHR();
+    void initialize(const VkVideoEncodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265PictureInfoKHR*>(this); }
+    VkVideoEncodeH265PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH265PictureInfoKHR const*>(this); }
+};
+struct VideoEncodeH265DpbSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo{};
+
+    VideoEncodeH265DpbSlotInfoKHR(const VkVideoEncodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoEncodeH265DpbSlotInfoKHR(const VideoEncodeH265DpbSlotInfoKHR& copy_src);
+    VideoEncodeH265DpbSlotInfoKHR& operator=(const VideoEncodeH265DpbSlotInfoKHR& copy_src);
+    VideoEncodeH265DpbSlotInfoKHR();
+    ~VideoEncodeH265DpbSlotInfoKHR();
+    void initialize(const VkVideoEncodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265DpbSlotInfoKHR*>(this); }
+    VkVideoEncodeH265DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH265DpbSlotInfoKHR const*>(this); }
+};
+struct VideoEncodeH265ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoH265ProfileIdc stdProfileIdc;
+
+    VideoEncodeH265ProfileInfoKHR(const VkVideoEncodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoEncodeH265ProfileInfoKHR(const VideoEncodeH265ProfileInfoKHR& copy_src);
+    VideoEncodeH265ProfileInfoKHR& operator=(const VideoEncodeH265ProfileInfoKHR& copy_src);
+    VideoEncodeH265ProfileInfoKHR();
+    ~VideoEncodeH265ProfileInfoKHR();
+    void initialize(const VkVideoEncodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265ProfileInfoKHR*>(this); }
+    VkVideoEncodeH265ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH265ProfileInfoKHR const*>(this); }
+};
+struct VideoEncodeH265RateControlInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeH265RateControlFlagsKHR flags;
+    uint32_t gopFrameCount;
+    uint32_t idrPeriod;
+    uint32_t consecutiveBFrameCount;
+    uint32_t subLayerCount;
+
+    VideoEncodeH265RateControlInfoKHR(const VkVideoEncodeH265RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    VideoEncodeH265RateControlInfoKHR(const VideoEncodeH265RateControlInfoKHR& copy_src);
+    VideoEncodeH265RateControlInfoKHR& operator=(const VideoEncodeH265RateControlInfoKHR& copy_src);
+    VideoEncodeH265RateControlInfoKHR();
+    ~VideoEncodeH265RateControlInfoKHR();
+    void initialize(const VkVideoEncodeH265RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265RateControlInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265RateControlInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265RateControlInfoKHR*>(this); }
+    VkVideoEncodeH265RateControlInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265RateControlInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH265RateControlLayerInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useMinQp;
+    VkVideoEncodeH265QpKHR minQp;
+    VkBool32 useMaxQp;
+    VkVideoEncodeH265QpKHR maxQp;
+    VkBool32 useMaxFrameSize;
+    VkVideoEncodeH265FrameSizeKHR maxFrameSize;
+
+    VideoEncodeH265RateControlLayerInfoKHR(const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH265RateControlLayerInfoKHR(const VideoEncodeH265RateControlLayerInfoKHR& copy_src);
+    VideoEncodeH265RateControlLayerInfoKHR& operator=(const VideoEncodeH265RateControlLayerInfoKHR& copy_src);
+    VideoEncodeH265RateControlLayerInfoKHR();
+    ~VideoEncodeH265RateControlLayerInfoKHR();
+    void initialize(const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265RateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265RateControlLayerInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoKHR*>(this); }
+    VkVideoEncodeH265RateControlLayerInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeH265GopRemainingFrameInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useGopRemainingFrames;
+    uint32_t gopRemainingI;
+    uint32_t gopRemainingP;
+    uint32_t gopRemainingB;
+
+    VideoEncodeH265GopRemainingFrameInfoKHR(const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeH265GopRemainingFrameInfoKHR(const VideoEncodeH265GopRemainingFrameInfoKHR& copy_src);
+    VideoEncodeH265GopRemainingFrameInfoKHR& operator=(const VideoEncodeH265GopRemainingFrameInfoKHR& copy_src);
+    VideoEncodeH265GopRemainingFrameInfoKHR();
+    ~VideoEncodeH265GopRemainingFrameInfoKHR();
+    void initialize(const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeH265GopRemainingFrameInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265GopRemainingFrameInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265GopRemainingFrameInfoKHR*>(this); }
+    VkVideoEncodeH265GopRemainingFrameInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265GopRemainingFrameInfoKHR const*>(this);
+    }
+};
+struct VideoDecodeH264ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoH264ProfileIdc stdProfileIdc;
+    VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout;
+
+    VideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoDecodeH264ProfileInfoKHR(const VideoDecodeH264ProfileInfoKHR& copy_src);
+    VideoDecodeH264ProfileInfoKHR& operator=(const VideoDecodeH264ProfileInfoKHR& copy_src);
+    VideoDecodeH264ProfileInfoKHR();
+    ~VideoDecodeH264ProfileInfoKHR();
+    void initialize(const VkVideoDecodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH264ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH264ProfileInfoKHR*>(this); }
+    VkVideoDecodeH264ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH264ProfileInfoKHR const*>(this); }
+};
+struct VideoDecodeH264CapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    StdVideoH264LevelIdc maxLevelIdc;
+    VkOffset2D fieldOffsetGranularity;
+
+    VideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    VideoDecodeH264CapabilitiesKHR(const VideoDecodeH264CapabilitiesKHR& copy_src);
+    VideoDecodeH264CapabilitiesKHR& operator=(const VideoDecodeH264CapabilitiesKHR& copy_src);
+    VideoDecodeH264CapabilitiesKHR();
+    ~VideoDecodeH264CapabilitiesKHR();
+    void initialize(const VkVideoDecodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH264CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoDecodeH264CapabilitiesKHR*>(this); }
+    VkVideoDecodeH264CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH264CapabilitiesKHR const*>(this); }
+};
+struct VideoDecodeH264SessionParametersAddInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stdSPSCount;
+    const StdVideoH264SequenceParameterSet* pStdSPSs{};
+    uint32_t stdPPSCount;
+    const StdVideoH264PictureParameterSet* pStdPPSs{};
+
+    VideoDecodeH264SessionParametersAddInfoKHR(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoDecodeH264SessionParametersAddInfoKHR(const VideoDecodeH264SessionParametersAddInfoKHR& copy_src);
+    VideoDecodeH264SessionParametersAddInfoKHR& operator=(const VideoDecodeH264SessionParametersAddInfoKHR& copy_src);
+    VideoDecodeH264SessionParametersAddInfoKHR();
+    ~VideoDecodeH264SessionParametersAddInfoKHR();
+    void initialize(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH264SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264SessionParametersAddInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoKHR*>(this);
+    }
+    VkVideoDecodeH264SessionParametersAddInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoKHR const*>(this);
+    }
+};
+struct VideoDecodeH264SessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxStdSPSCount;
+    uint32_t maxStdPPSCount;
+    VideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo{};
+
+    VideoDecodeH264SessionParametersCreateInfoKHR(const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoDecodeH264SessionParametersCreateInfoKHR(const VideoDecodeH264SessionParametersCreateInfoKHR& copy_src);
+    VideoDecodeH264SessionParametersCreateInfoKHR& operator=(const VideoDecodeH264SessionParametersCreateInfoKHR& copy_src);
+    VideoDecodeH264SessionParametersCreateInfoKHR();
+    ~VideoDecodeH264SessionParametersCreateInfoKHR();
+    void initialize(const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH264SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoDecodeH264SessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct VideoDecodeH264PictureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeH264PictureInfo* pStdPictureInfo{};
+    uint32_t sliceCount;
+    const uint32_t* pSliceOffsets{};
+
+    VideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoDecodeH264PictureInfoKHR(const VideoDecodeH264PictureInfoKHR& copy_src);
+    VideoDecodeH264PictureInfoKHR& operator=(const VideoDecodeH264PictureInfoKHR& copy_src);
+    VideoDecodeH264PictureInfoKHR();
+    ~VideoDecodeH264PictureInfoKHR();
+    void initialize(const VkVideoDecodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH264PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH264PictureInfoKHR*>(this); }
+    VkVideoDecodeH264PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH264PictureInfoKHR const*>(this); }
+};
+struct VideoDecodeH264DpbSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo{};
+
+    VideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoDecodeH264DpbSlotInfoKHR(const VideoDecodeH264DpbSlotInfoKHR& copy_src);
+    VideoDecodeH264DpbSlotInfoKHR& operator=(const VideoDecodeH264DpbSlotInfoKHR& copy_src);
+    VideoDecodeH264DpbSlotInfoKHR();
+    ~VideoDecodeH264DpbSlotInfoKHR();
+    void initialize(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH264DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR*>(this); }
+    VkVideoDecodeH264DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR const*>(this); }
+};
+struct RenderingFragmentShadingRateAttachmentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+    VkImageLayout imageLayout;
+    VkExtent2D shadingRateAttachmentTexelSize;
+
+    RenderingFragmentShadingRateAttachmentInfoKHR(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderingFragmentShadingRateAttachmentInfoKHR(const RenderingFragmentShadingRateAttachmentInfoKHR& copy_src);
+    RenderingFragmentShadingRateAttachmentInfoKHR& operator=(const RenderingFragmentShadingRateAttachmentInfoKHR& copy_src);
+    RenderingFragmentShadingRateAttachmentInfoKHR();
+    ~RenderingFragmentShadingRateAttachmentInfoKHR();
+    void initialize(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderingFragmentShadingRateAttachmentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingFragmentShadingRateAttachmentInfoKHR* ptr() {
+        return reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(this);
+    }
+    VkRenderingFragmentShadingRateAttachmentInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR const*>(this);
+    }
+};
+struct RenderingFragmentDensityMapAttachmentInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+    VkImageLayout imageLayout;
+
+    RenderingFragmentDensityMapAttachmentInfoEXT(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderingFragmentDensityMapAttachmentInfoEXT(const RenderingFragmentDensityMapAttachmentInfoEXT& copy_src);
+    RenderingFragmentDensityMapAttachmentInfoEXT& operator=(const RenderingFragmentDensityMapAttachmentInfoEXT& copy_src);
+    RenderingFragmentDensityMapAttachmentInfoEXT();
+    ~RenderingFragmentDensityMapAttachmentInfoEXT();
+    void initialize(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderingFragmentDensityMapAttachmentInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingFragmentDensityMapAttachmentInfoEXT* ptr() {
+        return reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(this);
+    }
+    VkRenderingFragmentDensityMapAttachmentInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT const*>(this);
+    }
+};
+struct AttachmentSampleCountInfoAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t colorAttachmentCount;
+    const VkSampleCountFlagBits* pColorAttachmentSamples{};
+    VkSampleCountFlagBits depthStencilAttachmentSamples;
+
+    AttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    AttachmentSampleCountInfoAMD(const AttachmentSampleCountInfoAMD& copy_src);
+    AttachmentSampleCountInfoAMD& operator=(const AttachmentSampleCountInfoAMD& copy_src);
+    AttachmentSampleCountInfoAMD();
+    ~AttachmentSampleCountInfoAMD();
+    void initialize(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AttachmentSampleCountInfoAMD* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentSampleCountInfoAMD* ptr() { return reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(this); }
+    VkAttachmentSampleCountInfoAMD const* ptr() const { return reinterpret_cast<VkAttachmentSampleCountInfoAMD const*>(this); }
+};
+struct MultiviewPerViewAttributesInfoNVX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 perViewAttributes;
+    VkBool32 perViewAttributesPositionXOnly;
+
+    MultiviewPerViewAttributesInfoNVX(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    MultiviewPerViewAttributesInfoNVX(const MultiviewPerViewAttributesInfoNVX& copy_src);
+    MultiviewPerViewAttributesInfoNVX& operator=(const MultiviewPerViewAttributesInfoNVX& copy_src);
+    MultiviewPerViewAttributesInfoNVX();
+    ~MultiviewPerViewAttributesInfoNVX();
+    void initialize(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MultiviewPerViewAttributesInfoNVX* 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 ImportMemoryWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+    HANDLE handle;
+    LPCWSTR name;
+
+    ImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    ImportMemoryWin32HandleInfoKHR(const ImportMemoryWin32HandleInfoKHR& copy_src);
+    ImportMemoryWin32HandleInfoKHR& operator=(const ImportMemoryWin32HandleInfoKHR& copy_src);
+    ImportMemoryWin32HandleInfoKHR();
+    ~ImportMemoryWin32HandleInfoKHR();
+    void initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportMemoryWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this); }
+    VkImportMemoryWin32HandleInfoKHR const* ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR const*>(this); }
+};
+struct ExportMemoryWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const SECURITY_ATTRIBUTES* pAttributes{};
+    DWORD dwAccess;
+    LPCWSTR name;
+
+    ExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    ExportMemoryWin32HandleInfoKHR(const ExportMemoryWin32HandleInfoKHR& copy_src);
+    ExportMemoryWin32HandleInfoKHR& operator=(const ExportMemoryWin32HandleInfoKHR& copy_src);
+    ExportMemoryWin32HandleInfoKHR();
+    ~ExportMemoryWin32HandleInfoKHR();
+    void initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMemoryWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkExportMemoryWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this); }
+    VkExportMemoryWin32HandleInfoKHR const* ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR const*>(this); }
+};
+struct MemoryWin32HandlePropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryTypeBits;
+
+    MemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    MemoryWin32HandlePropertiesKHR(const MemoryWin32HandlePropertiesKHR& copy_src);
+    MemoryWin32HandlePropertiesKHR& operator=(const MemoryWin32HandlePropertiesKHR& copy_src);
+    MemoryWin32HandlePropertiesKHR();
+    ~MemoryWin32HandlePropertiesKHR();
+    void initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryWin32HandlePropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryWin32HandlePropertiesKHR* ptr() { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this); }
+    VkMemoryWin32HandlePropertiesKHR const* ptr() const { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR const*>(this); }
+};
+struct MemoryGetWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    MemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    MemoryGetWin32HandleInfoKHR(const MemoryGetWin32HandleInfoKHR& copy_src);
+    MemoryGetWin32HandleInfoKHR& operator=(const MemoryGetWin32HandleInfoKHR& copy_src);
+    MemoryGetWin32HandleInfoKHR();
+    ~MemoryGetWin32HandleInfoKHR();
+    void initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryGetWin32HandleInfoKHR* 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 ImportMemoryFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+    int fd;
+
+    ImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImportMemoryFdInfoKHR(const ImportMemoryFdInfoKHR& copy_src);
+    ImportMemoryFdInfoKHR& operator=(const ImportMemoryFdInfoKHR& copy_src);
+    ImportMemoryFdInfoKHR();
+    ~ImportMemoryFdInfoKHR();
+    void initialize(const VkImportMemoryFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportMemoryFdInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryFdInfoKHR* ptr() { return reinterpret_cast<VkImportMemoryFdInfoKHR*>(this); }
+    VkImportMemoryFdInfoKHR const* ptr() const { return reinterpret_cast<VkImportMemoryFdInfoKHR const*>(this); }
+};
+struct MemoryFdPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryTypeBits;
+
+    MemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryFdPropertiesKHR(const MemoryFdPropertiesKHR& copy_src);
+    MemoryFdPropertiesKHR& operator=(const MemoryFdPropertiesKHR& copy_src);
+    MemoryFdPropertiesKHR();
+    ~MemoryFdPropertiesKHR();
+    void initialize(const VkMemoryFdPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryFdPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryFdPropertiesKHR* ptr() { return reinterpret_cast<VkMemoryFdPropertiesKHR*>(this); }
+    VkMemoryFdPropertiesKHR const* ptr() const { return reinterpret_cast<VkMemoryFdPropertiesKHR const*>(this); }
+};
+struct MemoryGetFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    MemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryGetFdInfoKHR(const MemoryGetFdInfoKHR& copy_src);
+    MemoryGetFdInfoKHR& operator=(const MemoryGetFdInfoKHR& copy_src);
+    MemoryGetFdInfoKHR();
+    ~MemoryGetFdInfoKHR();
+    void initialize(const VkMemoryGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryGetFdInfoKHR* 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 Win32KeyedMutexAcquireReleaseInfoKHR {
+    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{};
+
+    Win32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    Win32KeyedMutexAcquireReleaseInfoKHR(const Win32KeyedMutexAcquireReleaseInfoKHR& copy_src);
+    Win32KeyedMutexAcquireReleaseInfoKHR& operator=(const Win32KeyedMutexAcquireReleaseInfoKHR& copy_src);
+    Win32KeyedMutexAcquireReleaseInfoKHR();
+    ~Win32KeyedMutexAcquireReleaseInfoKHR();
+    void initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const Win32KeyedMutexAcquireReleaseInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkWin32KeyedMutexAcquireReleaseInfoKHR* ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this); }
+    VkWin32KeyedMutexAcquireReleaseInfoKHR const* ptr() const {
+        return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR const*>(this);
+    }
+};
+struct ImportSemaphoreWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkSemaphoreImportFlags flags;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+    HANDLE handle;
+    LPCWSTR name;
+
+    ImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    ImportSemaphoreWin32HandleInfoKHR(const ImportSemaphoreWin32HandleInfoKHR& copy_src);
+    ImportSemaphoreWin32HandleInfoKHR& operator=(const ImportSemaphoreWin32HandleInfoKHR& copy_src);
+    ImportSemaphoreWin32HandleInfoKHR();
+    ~ImportSemaphoreWin32HandleInfoKHR();
+    void initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportSemaphoreWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportSemaphoreWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this); }
+    VkImportSemaphoreWin32HandleInfoKHR const* ptr() const {
+        return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR const*>(this);
+    }
+};
+struct ExportSemaphoreWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const SECURITY_ATTRIBUTES* pAttributes{};
+    DWORD dwAccess;
+    LPCWSTR name;
+
+    ExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    ExportSemaphoreWin32HandleInfoKHR(const ExportSemaphoreWin32HandleInfoKHR& copy_src);
+    ExportSemaphoreWin32HandleInfoKHR& operator=(const ExportSemaphoreWin32HandleInfoKHR& copy_src);
+    ExportSemaphoreWin32HandleInfoKHR();
+    ~ExportSemaphoreWin32HandleInfoKHR();
+    void initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportSemaphoreWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkExportSemaphoreWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this); }
+    VkExportSemaphoreWin32HandleInfoKHR const* ptr() const {
+        return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR const*>(this);
+    }
+};
+struct D3D12FenceSubmitInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t waitSemaphoreValuesCount;
+    const uint64_t* pWaitSemaphoreValues{};
+    uint32_t signalSemaphoreValuesCount;
+    const uint64_t* pSignalSemaphoreValues{};
+
+    D3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    D3D12FenceSubmitInfoKHR(const D3D12FenceSubmitInfoKHR& copy_src);
+    D3D12FenceSubmitInfoKHR& operator=(const D3D12FenceSubmitInfoKHR& copy_src);
+    D3D12FenceSubmitInfoKHR();
+    ~D3D12FenceSubmitInfoKHR();
+    void initialize(const VkD3D12FenceSubmitInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const D3D12FenceSubmitInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkD3D12FenceSubmitInfoKHR* ptr() { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this); }
+    VkD3D12FenceSubmitInfoKHR const* ptr() const { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR const*>(this); }
+};
+struct SemaphoreGetWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+
+    SemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    SemaphoreGetWin32HandleInfoKHR(const SemaphoreGetWin32HandleInfoKHR& copy_src);
+    SemaphoreGetWin32HandleInfoKHR& operator=(const SemaphoreGetWin32HandleInfoKHR& copy_src);
+    SemaphoreGetWin32HandleInfoKHR();
+    ~SemaphoreGetWin32HandleInfoKHR();
+    void initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SemaphoreGetWin32HandleInfoKHR* 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 ImportSemaphoreFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkSemaphoreImportFlags flags;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+    int fd;
+
+    ImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImportSemaphoreFdInfoKHR(const ImportSemaphoreFdInfoKHR& copy_src);
+    ImportSemaphoreFdInfoKHR& operator=(const ImportSemaphoreFdInfoKHR& copy_src);
+    ImportSemaphoreFdInfoKHR();
+    ~ImportSemaphoreFdInfoKHR();
+    void initialize(const VkImportSemaphoreFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportSemaphoreFdInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportSemaphoreFdInfoKHR* ptr() { return reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this); }
+    VkImportSemaphoreFdInfoKHR const* ptr() const { return reinterpret_cast<VkImportSemaphoreFdInfoKHR const*>(this); }
+};
+struct SemaphoreGetFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+
+    SemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SemaphoreGetFdInfoKHR(const SemaphoreGetFdInfoKHR& copy_src);
+    SemaphoreGetFdInfoKHR& operator=(const SemaphoreGetFdInfoKHR& copy_src);
+    SemaphoreGetFdInfoKHR();
+    ~SemaphoreGetFdInfoKHR();
+    void initialize(const VkSemaphoreGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SemaphoreGetFdInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreGetFdInfoKHR* ptr() { return reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this); }
+    VkSemaphoreGetFdInfoKHR const* ptr() const { return reinterpret_cast<VkSemaphoreGetFdInfoKHR const*>(this); }
+};
+struct PhysicalDevicePushDescriptorPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxPushDescriptors;
+
+    PhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePushDescriptorPropertiesKHR(const PhysicalDevicePushDescriptorPropertiesKHR& copy_src);
+    PhysicalDevicePushDescriptorPropertiesKHR& operator=(const PhysicalDevicePushDescriptorPropertiesKHR& copy_src);
+    PhysicalDevicePushDescriptorPropertiesKHR();
+    ~PhysicalDevicePushDescriptorPropertiesKHR();
+    void initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePushDescriptorPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePushDescriptorPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
+    }
+    VkPhysicalDevicePushDescriptorPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR const*>(this);
+    }
+};
+struct PresentRegionKHR {
+    uint32_t rectangleCount;
+    const VkRectLayerKHR* pRectangles{};
+
+    PresentRegionKHR(const VkPresentRegionKHR* in_struct, PNextCopyState* copy_state = {});
+    PresentRegionKHR(const PresentRegionKHR& copy_src);
+    PresentRegionKHR& operator=(const PresentRegionKHR& copy_src);
+    PresentRegionKHR();
+    ~PresentRegionKHR();
+    void initialize(const VkPresentRegionKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PresentRegionKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPresentRegionKHR* ptr() { return reinterpret_cast<VkPresentRegionKHR*>(this); }
+    VkPresentRegionKHR const* ptr() const { return reinterpret_cast<VkPresentRegionKHR const*>(this); }
+};
+struct PresentRegionsKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    PresentRegionKHR* pRegions{};
+
+    PresentRegionsKHR(const VkPresentRegionsKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PresentRegionsKHR(const PresentRegionsKHR& copy_src);
+    PresentRegionsKHR& operator=(const PresentRegionsKHR& copy_src);
+    PresentRegionsKHR();
+    ~PresentRegionsKHR();
+    void initialize(const VkPresentRegionsKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PresentRegionsKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPresentRegionsKHR* ptr() { return reinterpret_cast<VkPresentRegionsKHR*>(this); }
+    VkPresentRegionsKHR const* ptr() const { return reinterpret_cast<VkPresentRegionsKHR const*>(this); }
+};
+struct SharedPresentSurfaceCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageUsageFlags sharedPresentSupportedUsageFlags;
+
+    SharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    SharedPresentSurfaceCapabilitiesKHR(const SharedPresentSurfaceCapabilitiesKHR& copy_src);
+    SharedPresentSurfaceCapabilitiesKHR& operator=(const SharedPresentSurfaceCapabilitiesKHR& copy_src);
+    SharedPresentSurfaceCapabilitiesKHR();
+    ~SharedPresentSurfaceCapabilitiesKHR();
+    void initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SharedPresentSurfaceCapabilitiesKHR* 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 ImportFenceWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFence fence;
+    VkFenceImportFlags flags;
+    VkExternalFenceHandleTypeFlagBits handleType;
+    HANDLE handle;
+    LPCWSTR name;
+
+    ImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    ImportFenceWin32HandleInfoKHR(const ImportFenceWin32HandleInfoKHR& copy_src);
+    ImportFenceWin32HandleInfoKHR& operator=(const ImportFenceWin32HandleInfoKHR& copy_src);
+    ImportFenceWin32HandleInfoKHR();
+    ~ImportFenceWin32HandleInfoKHR();
+    void initialize(const VkImportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportFenceWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportFenceWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this); }
+    VkImportFenceWin32HandleInfoKHR const* ptr() const { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR const*>(this); }
+};
+struct ExportFenceWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const SECURITY_ATTRIBUTES* pAttributes{};
+    DWORD dwAccess;
+    LPCWSTR name;
+
+    ExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    ExportFenceWin32HandleInfoKHR(const ExportFenceWin32HandleInfoKHR& copy_src);
+    ExportFenceWin32HandleInfoKHR& operator=(const ExportFenceWin32HandleInfoKHR& copy_src);
+    ExportFenceWin32HandleInfoKHR();
+    ~ExportFenceWin32HandleInfoKHR();
+    void initialize(const VkExportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportFenceWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkExportFenceWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this); }
+    VkExportFenceWin32HandleInfoKHR const* ptr() const { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR const*>(this); }
+};
+struct FenceGetWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFence fence;
+    VkExternalFenceHandleTypeFlagBits handleType;
+
+    FenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    FenceGetWin32HandleInfoKHR(const FenceGetWin32HandleInfoKHR& copy_src);
+    FenceGetWin32HandleInfoKHR& operator=(const FenceGetWin32HandleInfoKHR& copy_src);
+    FenceGetWin32HandleInfoKHR();
+    ~FenceGetWin32HandleInfoKHR();
+    void initialize(const VkFenceGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FenceGetWin32HandleInfoKHR* 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 ImportFenceFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFence fence;
+    VkFenceImportFlags flags;
+    VkExternalFenceHandleTypeFlagBits handleType;
+    int fd;
+
+    ImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImportFenceFdInfoKHR(const ImportFenceFdInfoKHR& copy_src);
+    ImportFenceFdInfoKHR& operator=(const ImportFenceFdInfoKHR& copy_src);
+    ImportFenceFdInfoKHR();
+    ~ImportFenceFdInfoKHR();
+    void initialize(const VkImportFenceFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportFenceFdInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportFenceFdInfoKHR* ptr() { return reinterpret_cast<VkImportFenceFdInfoKHR*>(this); }
+    VkImportFenceFdInfoKHR const* ptr() const { return reinterpret_cast<VkImportFenceFdInfoKHR const*>(this); }
+};
+struct FenceGetFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFence fence;
+    VkExternalFenceHandleTypeFlagBits handleType;
+
+    FenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    FenceGetFdInfoKHR(const FenceGetFdInfoKHR& copy_src);
+    FenceGetFdInfoKHR& operator=(const FenceGetFdInfoKHR& copy_src);
+    FenceGetFdInfoKHR();
+    ~FenceGetFdInfoKHR();
+    void initialize(const VkFenceGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FenceGetFdInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkFenceGetFdInfoKHR* ptr() { return reinterpret_cast<VkFenceGetFdInfoKHR*>(this); }
+    VkFenceGetFdInfoKHR const* ptr() const { return reinterpret_cast<VkFenceGetFdInfoKHR const*>(this); }
+};
+struct PhysicalDevicePerformanceQueryFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 performanceCounterQueryPools;
+    VkBool32 performanceCounterMultipleQueryPools;
+
+    PhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePerformanceQueryFeaturesKHR(const PhysicalDevicePerformanceQueryFeaturesKHR& copy_src);
+    PhysicalDevicePerformanceQueryFeaturesKHR& operator=(const PhysicalDevicePerformanceQueryFeaturesKHR& copy_src);
+    PhysicalDevicePerformanceQueryFeaturesKHR();
+    ~PhysicalDevicePerformanceQueryFeaturesKHR();
+    void initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePerformanceQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePerformanceQueryFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(this);
+    }
+    VkPhysicalDevicePerformanceQueryFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDevicePerformanceQueryPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 allowCommandBufferQueryCopies;
+
+    PhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePerformanceQueryPropertiesKHR(const PhysicalDevicePerformanceQueryPropertiesKHR& copy_src);
+    PhysicalDevicePerformanceQueryPropertiesKHR& operator=(const PhysicalDevicePerformanceQueryPropertiesKHR& copy_src);
+    PhysicalDevicePerformanceQueryPropertiesKHR();
+    ~PhysicalDevicePerformanceQueryPropertiesKHR();
+    void initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePerformanceQueryPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePerformanceQueryPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(this);
+    }
+    VkPhysicalDevicePerformanceQueryPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR const*>(this);
+    }
+};
+struct PerformanceCounterKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkPerformanceCounterUnitKHR unit;
+    VkPerformanceCounterScopeKHR scope;
+    VkPerformanceCounterStorageKHR storage;
+    uint8_t uuid[VK_UUID_SIZE];
+
+    PerformanceCounterKHR(const VkPerformanceCounterKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PerformanceCounterKHR(const PerformanceCounterKHR& copy_src);
+    PerformanceCounterKHR& operator=(const PerformanceCounterKHR& copy_src);
+    PerformanceCounterKHR();
+    ~PerformanceCounterKHR();
+    void initialize(const VkPerformanceCounterKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PerformanceCounterKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceCounterKHR* ptr() { return reinterpret_cast<VkPerformanceCounterKHR*>(this); }
+    VkPerformanceCounterKHR const* ptr() const { return reinterpret_cast<VkPerformanceCounterKHR const*>(this); }
+};
+struct PerformanceCounterDescriptionKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkPerformanceCounterDescriptionFlagsKHR flags;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char category[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+
+    PerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    PerformanceCounterDescriptionKHR(const PerformanceCounterDescriptionKHR& copy_src);
+    PerformanceCounterDescriptionKHR& operator=(const PerformanceCounterDescriptionKHR& copy_src);
+    PerformanceCounterDescriptionKHR();
+    ~PerformanceCounterDescriptionKHR();
+    void initialize(const VkPerformanceCounterDescriptionKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PerformanceCounterDescriptionKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceCounterDescriptionKHR* ptr() { return reinterpret_cast<VkPerformanceCounterDescriptionKHR*>(this); }
+    VkPerformanceCounterDescriptionKHR const* ptr() const {
+        return reinterpret_cast<VkPerformanceCounterDescriptionKHR const*>(this);
+    }
+};
+struct QueryPoolPerformanceCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t queueFamilyIndex;
+    uint32_t counterIndexCount;
+    const uint32_t* pCounterIndices{};
+
+    QueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    QueryPoolPerformanceCreateInfoKHR(const QueryPoolPerformanceCreateInfoKHR& copy_src);
+    QueryPoolPerformanceCreateInfoKHR& operator=(const QueryPoolPerformanceCreateInfoKHR& copy_src);
+    QueryPoolPerformanceCreateInfoKHR();
+    ~QueryPoolPerformanceCreateInfoKHR();
+    void initialize(const VkQueryPoolPerformanceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const QueryPoolPerformanceCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkQueryPoolPerformanceCreateInfoKHR* ptr() { return reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(this); }
+    VkQueryPoolPerformanceCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR const*>(this);
+    }
+};
+struct AcquireProfilingLockInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAcquireProfilingLockFlagsKHR flags;
+    uint64_t timeout;
+
+    AcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    AcquireProfilingLockInfoKHR(const AcquireProfilingLockInfoKHR& copy_src);
+    AcquireProfilingLockInfoKHR& operator=(const AcquireProfilingLockInfoKHR& copy_src);
+    AcquireProfilingLockInfoKHR();
+    ~AcquireProfilingLockInfoKHR();
+    void initialize(const VkAcquireProfilingLockInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AcquireProfilingLockInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAcquireProfilingLockInfoKHR* ptr() { return reinterpret_cast<VkAcquireProfilingLockInfoKHR*>(this); }
+    VkAcquireProfilingLockInfoKHR const* ptr() const { return reinterpret_cast<VkAcquireProfilingLockInfoKHR const*>(this); }
+};
+struct PerformanceQuerySubmitInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t counterPassIndex;
+
+    PerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    PerformanceQuerySubmitInfoKHR(const PerformanceQuerySubmitInfoKHR& copy_src);
+    PerformanceQuerySubmitInfoKHR& operator=(const PerformanceQuerySubmitInfoKHR& copy_src);
+    PerformanceQuerySubmitInfoKHR();
+    ~PerformanceQuerySubmitInfoKHR();
+    void initialize(const VkPerformanceQuerySubmitInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PerformanceQuerySubmitInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceQuerySubmitInfoKHR* ptr() { return reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(this); }
+    VkPerformanceQuerySubmitInfoKHR const* ptr() const { return reinterpret_cast<VkPerformanceQuerySubmitInfoKHR const*>(this); }
+};
+struct PhysicalDeviceSurfaceInfo2KHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSurfaceKHR surface;
+
+    PhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    PhysicalDeviceSurfaceInfo2KHR(const PhysicalDeviceSurfaceInfo2KHR& copy_src);
+    PhysicalDeviceSurfaceInfo2KHR& operator=(const PhysicalDeviceSurfaceInfo2KHR& copy_src);
+    PhysicalDeviceSurfaceInfo2KHR();
+    ~PhysicalDeviceSurfaceInfo2KHR();
+    void initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSurfaceInfo2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSurfaceInfo2KHR* ptr() { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this); }
+    VkPhysicalDeviceSurfaceInfo2KHR const* ptr() const { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR const*>(this); }
+};
+struct SurfaceCapabilities2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkSurfaceCapabilitiesKHR surfaceCapabilities;
+
+    SurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SurfaceCapabilities2KHR(const SurfaceCapabilities2KHR& copy_src);
+    SurfaceCapabilities2KHR& operator=(const SurfaceCapabilities2KHR& copy_src);
+    SurfaceCapabilities2KHR();
+    ~SurfaceCapabilities2KHR();
+    void initialize(const VkSurfaceCapabilities2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SurfaceCapabilities2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceCapabilities2KHR* ptr() { return reinterpret_cast<VkSurfaceCapabilities2KHR*>(this); }
+    VkSurfaceCapabilities2KHR const* ptr() const { return reinterpret_cast<VkSurfaceCapabilities2KHR const*>(this); }
+};
+struct SurfaceFormat2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkSurfaceFormatKHR surfaceFormat;
+
+    SurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SurfaceFormat2KHR(const SurfaceFormat2KHR& copy_src);
+    SurfaceFormat2KHR& operator=(const SurfaceFormat2KHR& copy_src);
+    SurfaceFormat2KHR();
+    ~SurfaceFormat2KHR();
+    void initialize(const VkSurfaceFormat2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SurfaceFormat2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceFormat2KHR* ptr() { return reinterpret_cast<VkSurfaceFormat2KHR*>(this); }
+    VkSurfaceFormat2KHR const* ptr() const { return reinterpret_cast<VkSurfaceFormat2KHR const*>(this); }
+};
+struct DisplayProperties2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    DisplayPropertiesKHR displayProperties;
+
+    DisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DisplayProperties2KHR(const DisplayProperties2KHR& copy_src);
+    DisplayProperties2KHR& operator=(const DisplayProperties2KHR& copy_src);
+    DisplayProperties2KHR();
+    ~DisplayProperties2KHR();
+    void initialize(const VkDisplayProperties2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplayProperties2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayProperties2KHR* ptr() { return reinterpret_cast<VkDisplayProperties2KHR*>(this); }
+    VkDisplayProperties2KHR const* ptr() const { return reinterpret_cast<VkDisplayProperties2KHR const*>(this); }
+};
+struct DisplayPlaneProperties2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkDisplayPlanePropertiesKHR displayPlaneProperties;
+
+    DisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    DisplayPlaneProperties2KHR(const DisplayPlaneProperties2KHR& copy_src);
+    DisplayPlaneProperties2KHR& operator=(const DisplayPlaneProperties2KHR& copy_src);
+    DisplayPlaneProperties2KHR();
+    ~DisplayPlaneProperties2KHR();
+    void initialize(const VkDisplayPlaneProperties2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplayPlaneProperties2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayPlaneProperties2KHR* ptr() { return reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this); }
+    VkDisplayPlaneProperties2KHR const* ptr() const { return reinterpret_cast<VkDisplayPlaneProperties2KHR const*>(this); }
+};
+struct DisplayModeProperties2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkDisplayModePropertiesKHR displayModeProperties;
+
+    DisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    DisplayModeProperties2KHR(const DisplayModeProperties2KHR& copy_src);
+    DisplayModeProperties2KHR& operator=(const DisplayModeProperties2KHR& copy_src);
+    DisplayModeProperties2KHR();
+    ~DisplayModeProperties2KHR();
+    void initialize(const VkDisplayModeProperties2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplayModeProperties2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayModeProperties2KHR* ptr() { return reinterpret_cast<VkDisplayModeProperties2KHR*>(this); }
+    VkDisplayModeProperties2KHR const* ptr() const { return reinterpret_cast<VkDisplayModeProperties2KHR const*>(this); }
+};
+struct DisplayPlaneInfo2KHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDisplayModeKHR mode;
+    uint32_t planeIndex;
+
+    DisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DisplayPlaneInfo2KHR(const DisplayPlaneInfo2KHR& copy_src);
+    DisplayPlaneInfo2KHR& operator=(const DisplayPlaneInfo2KHR& copy_src);
+    DisplayPlaneInfo2KHR();
+    ~DisplayPlaneInfo2KHR();
+    void initialize(const VkDisplayPlaneInfo2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplayPlaneInfo2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayPlaneInfo2KHR* ptr() { return reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this); }
+    VkDisplayPlaneInfo2KHR const* ptr() const { return reinterpret_cast<VkDisplayPlaneInfo2KHR const*>(this); }
+};
+struct DisplayPlaneCapabilities2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkDisplayPlaneCapabilitiesKHR capabilities;
+
+    DisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    DisplayPlaneCapabilities2KHR(const DisplayPlaneCapabilities2KHR& copy_src);
+    DisplayPlaneCapabilities2KHR& operator=(const DisplayPlaneCapabilities2KHR& copy_src);
+    DisplayPlaneCapabilities2KHR();
+    ~DisplayPlaneCapabilities2KHR();
+    void initialize(const VkDisplayPlaneCapabilities2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplayPlaneCapabilities2KHR* 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 PhysicalDevicePortabilitySubsetFeaturesKHR {
+    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;
+
+    PhysicalDevicePortabilitySubsetFeaturesKHR(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePortabilitySubsetFeaturesKHR(const PhysicalDevicePortabilitySubsetFeaturesKHR& copy_src);
+    PhysicalDevicePortabilitySubsetFeaturesKHR& operator=(const PhysicalDevicePortabilitySubsetFeaturesKHR& copy_src);
+    PhysicalDevicePortabilitySubsetFeaturesKHR();
+    ~PhysicalDevicePortabilitySubsetFeaturesKHR();
+    void initialize(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePortabilitySubsetFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePortabilitySubsetFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(this);
+    }
+    VkPhysicalDevicePortabilitySubsetFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDevicePortabilitySubsetPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t minVertexInputBindingStrideAlignment;
+
+    PhysicalDevicePortabilitySubsetPropertiesKHR(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePortabilitySubsetPropertiesKHR(const PhysicalDevicePortabilitySubsetPropertiesKHR& copy_src);
+    PhysicalDevicePortabilitySubsetPropertiesKHR& operator=(const PhysicalDevicePortabilitySubsetPropertiesKHR& copy_src);
+    PhysicalDevicePortabilitySubsetPropertiesKHR();
+    ~PhysicalDevicePortabilitySubsetPropertiesKHR();
+    void initialize(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePortabilitySubsetPropertiesKHR* 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 PhysicalDeviceShaderClockFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderSubgroupClock;
+    VkBool32 shaderDeviceClock;
+
+    PhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDeviceShaderClockFeaturesKHR(const PhysicalDeviceShaderClockFeaturesKHR& copy_src);
+    PhysicalDeviceShaderClockFeaturesKHR& operator=(const PhysicalDeviceShaderClockFeaturesKHR& copy_src);
+    PhysicalDeviceShaderClockFeaturesKHR();
+    ~PhysicalDeviceShaderClockFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderClockFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderClockFeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(this); }
+    VkPhysicalDeviceShaderClockFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR const*>(this);
+    }
+};
+struct VideoDecodeH265ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoH265ProfileIdc stdProfileIdc;
+
+    VideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoDecodeH265ProfileInfoKHR(const VideoDecodeH265ProfileInfoKHR& copy_src);
+    VideoDecodeH265ProfileInfoKHR& operator=(const VideoDecodeH265ProfileInfoKHR& copy_src);
+    VideoDecodeH265ProfileInfoKHR();
+    ~VideoDecodeH265ProfileInfoKHR();
+    void initialize(const VkVideoDecodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH265ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH265ProfileInfoKHR*>(this); }
+    VkVideoDecodeH265ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH265ProfileInfoKHR const*>(this); }
+};
+struct VideoDecodeH265CapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    StdVideoH265LevelIdc maxLevelIdc;
+
+    VideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    VideoDecodeH265CapabilitiesKHR(const VideoDecodeH265CapabilitiesKHR& copy_src);
+    VideoDecodeH265CapabilitiesKHR& operator=(const VideoDecodeH265CapabilitiesKHR& copy_src);
+    VideoDecodeH265CapabilitiesKHR();
+    ~VideoDecodeH265CapabilitiesKHR();
+    void initialize(const VkVideoDecodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH265CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoDecodeH265CapabilitiesKHR*>(this); }
+    VkVideoDecodeH265CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH265CapabilitiesKHR const*>(this); }
+};
+struct VideoDecodeH265SessionParametersAddInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stdVPSCount;
+    const StdVideoH265VideoParameterSet* pStdVPSs{};
+    uint32_t stdSPSCount;
+    const StdVideoH265SequenceParameterSet* pStdSPSs{};
+    uint32_t stdPPSCount;
+    const StdVideoH265PictureParameterSet* pStdPPSs{};
+
+    VideoDecodeH265SessionParametersAddInfoKHR(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoDecodeH265SessionParametersAddInfoKHR(const VideoDecodeH265SessionParametersAddInfoKHR& copy_src);
+    VideoDecodeH265SessionParametersAddInfoKHR& operator=(const VideoDecodeH265SessionParametersAddInfoKHR& copy_src);
+    VideoDecodeH265SessionParametersAddInfoKHR();
+    ~VideoDecodeH265SessionParametersAddInfoKHR();
+    void initialize(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH265SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265SessionParametersAddInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoKHR*>(this);
+    }
+    VkVideoDecodeH265SessionParametersAddInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoKHR const*>(this);
+    }
+};
+struct VideoDecodeH265SessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxStdVPSCount;
+    uint32_t maxStdSPSCount;
+    uint32_t maxStdPPSCount;
+    VideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo{};
+
+    VideoDecodeH265SessionParametersCreateInfoKHR(const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoDecodeH265SessionParametersCreateInfoKHR(const VideoDecodeH265SessionParametersCreateInfoKHR& copy_src);
+    VideoDecodeH265SessionParametersCreateInfoKHR& operator=(const VideoDecodeH265SessionParametersCreateInfoKHR& copy_src);
+    VideoDecodeH265SessionParametersCreateInfoKHR();
+    ~VideoDecodeH265SessionParametersCreateInfoKHR();
+    void initialize(const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH265SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoDecodeH265SessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct VideoDecodeH265PictureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeH265PictureInfo* pStdPictureInfo{};
+    uint32_t sliceSegmentCount;
+    const uint32_t* pSliceSegmentOffsets{};
+
+    VideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoDecodeH265PictureInfoKHR(const VideoDecodeH265PictureInfoKHR& copy_src);
+    VideoDecodeH265PictureInfoKHR& operator=(const VideoDecodeH265PictureInfoKHR& copy_src);
+    VideoDecodeH265PictureInfoKHR();
+    ~VideoDecodeH265PictureInfoKHR();
+    void initialize(const VkVideoDecodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH265PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH265PictureInfoKHR*>(this); }
+    VkVideoDecodeH265PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH265PictureInfoKHR const*>(this); }
+};
+struct VideoDecodeH265DpbSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo{};
+
+    VideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoDecodeH265DpbSlotInfoKHR(const VideoDecodeH265DpbSlotInfoKHR& copy_src);
+    VideoDecodeH265DpbSlotInfoKHR& operator=(const VideoDecodeH265DpbSlotInfoKHR& copy_src);
+    VideoDecodeH265DpbSlotInfoKHR();
+    ~VideoDecodeH265DpbSlotInfoKHR();
+    void initialize(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeH265DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR*>(this); }
+    VkVideoDecodeH265DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR const*>(this); }
+};
+struct DeviceQueueGlobalPriorityCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueueGlobalPriorityKHR globalPriority;
+
+    DeviceQueueGlobalPriorityCreateInfoKHR(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DeviceQueueGlobalPriorityCreateInfoKHR(const DeviceQueueGlobalPriorityCreateInfoKHR& copy_src);
+    DeviceQueueGlobalPriorityCreateInfoKHR& operator=(const DeviceQueueGlobalPriorityCreateInfoKHR& copy_src);
+    DeviceQueueGlobalPriorityCreateInfoKHR();
+    ~DeviceQueueGlobalPriorityCreateInfoKHR();
+    void initialize(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceQueueGlobalPriorityCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceQueueGlobalPriorityCreateInfoKHR* ptr() { return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR*>(this); }
+    VkDeviceQueueGlobalPriorityCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR const*>(this);
+    }
+};
+struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 globalPriorityQuery;
+
+    PhysicalDeviceGlobalPriorityQueryFeaturesKHR(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceGlobalPriorityQueryFeaturesKHR(const PhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src);
+    PhysicalDeviceGlobalPriorityQueryFeaturesKHR& operator=(const PhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src);
+    PhysicalDeviceGlobalPriorityQueryFeaturesKHR();
+    ~PhysicalDeviceGlobalPriorityQueryFeaturesKHR();
+    void initialize(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceGlobalPriorityQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR const*>(this);
+    }
+};
+struct QueueFamilyGlobalPriorityPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t priorityCount;
+    VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR];
+
+    QueueFamilyGlobalPriorityPropertiesKHR(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    QueueFamilyGlobalPriorityPropertiesKHR(const QueueFamilyGlobalPriorityPropertiesKHR& copy_src);
+    QueueFamilyGlobalPriorityPropertiesKHR& operator=(const QueueFamilyGlobalPriorityPropertiesKHR& copy_src);
+    QueueFamilyGlobalPriorityPropertiesKHR();
+    ~QueueFamilyGlobalPriorityPropertiesKHR();
+    void initialize(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const QueueFamilyGlobalPriorityPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyGlobalPriorityPropertiesKHR* ptr() { return reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR*>(this); }
+    VkQueueFamilyGlobalPriorityPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR const*>(this);
+    }
+};
+struct FragmentShadingRateAttachmentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    AttachmentReference2* pFragmentShadingRateAttachment{};
+    VkExtent2D shadingRateAttachmentTexelSize;
+
+    FragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    FragmentShadingRateAttachmentInfoKHR(const FragmentShadingRateAttachmentInfoKHR& copy_src);
+    FragmentShadingRateAttachmentInfoKHR& operator=(const FragmentShadingRateAttachmentInfoKHR& copy_src);
+    FragmentShadingRateAttachmentInfoKHR();
+    ~FragmentShadingRateAttachmentInfoKHR();
+    void initialize(const VkFragmentShadingRateAttachmentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FragmentShadingRateAttachmentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkFragmentShadingRateAttachmentInfoKHR* ptr() { return reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(this); }
+    VkFragmentShadingRateAttachmentInfoKHR const* ptr() const {
+        return reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR const*>(this);
+    }
+};
+struct PipelineFragmentShadingRateStateCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExtent2D fragmentSize;
+    VkFragmentShadingRateCombinerOpKHR combinerOps[2];
+
+    PipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineFragmentShadingRateStateCreateInfoKHR(const PipelineFragmentShadingRateStateCreateInfoKHR& copy_src);
+    PipelineFragmentShadingRateStateCreateInfoKHR& operator=(const PipelineFragmentShadingRateStateCreateInfoKHR& copy_src);
+    PipelineFragmentShadingRateStateCreateInfoKHR();
+    ~PipelineFragmentShadingRateStateCreateInfoKHR();
+    void initialize(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineFragmentShadingRateStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineFragmentShadingRateStateCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(this);
+    }
+    VkPipelineFragmentShadingRateStateCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR const*>(this);
+    }
+};
+struct PhysicalDeviceFragmentShadingRateFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineFragmentShadingRate;
+    VkBool32 primitiveFragmentShadingRate;
+    VkBool32 attachmentFragmentShadingRate;
+
+    PhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentShadingRateFeaturesKHR(const PhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src);
+    PhysicalDeviceFragmentShadingRateFeaturesKHR& operator=(const PhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src);
+    PhysicalDeviceFragmentShadingRateFeaturesKHR();
+    ~PhysicalDeviceFragmentShadingRateFeaturesKHR();
+    void initialize(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentShadingRateFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShadingRateFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceFragmentShadingRateFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceFragmentShadingRatePropertiesKHR {
+    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;
+
+    PhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentShadingRatePropertiesKHR(const PhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src);
+    PhysicalDeviceFragmentShadingRatePropertiesKHR& operator=(const PhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src);
+    PhysicalDeviceFragmentShadingRatePropertiesKHR();
+    ~PhysicalDeviceFragmentShadingRatePropertiesKHR();
+    void initialize(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentShadingRatePropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShadingRatePropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceFragmentShadingRatePropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceFragmentShadingRateKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkSampleCountFlags sampleCounts;
+    VkExtent2D fragmentSize;
+
+    PhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDeviceFragmentShadingRateKHR(const PhysicalDeviceFragmentShadingRateKHR& copy_src);
+    PhysicalDeviceFragmentShadingRateKHR& operator=(const PhysicalDeviceFragmentShadingRateKHR& copy_src);
+    PhysicalDeviceFragmentShadingRateKHR();
+    ~PhysicalDeviceFragmentShadingRateKHR();
+    void initialize(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentShadingRateKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShadingRateKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR*>(this); }
+    VkPhysicalDeviceFragmentShadingRateKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR const*>(this);
+    }
+};
+struct PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 dynamicRenderingLocalRead;
+
+    PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(const PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src);
+    PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& operator=(
+        const PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src);
+    PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR();
+    ~PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR();
+    void initialize(const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const*>(this);
+    }
+};
+struct RenderingAttachmentLocationInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t colorAttachmentCount;
+    const uint32_t* pColorAttachmentLocations{};
+
+    RenderingAttachmentLocationInfoKHR(const VkRenderingAttachmentLocationInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    RenderingAttachmentLocationInfoKHR(const RenderingAttachmentLocationInfoKHR& copy_src);
+    RenderingAttachmentLocationInfoKHR& operator=(const RenderingAttachmentLocationInfoKHR& copy_src);
+    RenderingAttachmentLocationInfoKHR();
+    ~RenderingAttachmentLocationInfoKHR();
+    void initialize(const VkRenderingAttachmentLocationInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderingAttachmentLocationInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingAttachmentLocationInfoKHR* ptr() { return reinterpret_cast<VkRenderingAttachmentLocationInfoKHR*>(this); }
+    VkRenderingAttachmentLocationInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRenderingAttachmentLocationInfoKHR const*>(this);
+    }
+};
+struct RenderingInputAttachmentIndexInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t colorAttachmentCount;
+    const uint32_t* pColorAttachmentInputIndices{};
+    const uint32_t* pDepthInputAttachmentIndex{};
+    const uint32_t* pStencilInputAttachmentIndex{};
+
+    RenderingInputAttachmentIndexInfoKHR(const VkRenderingInputAttachmentIndexInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    RenderingInputAttachmentIndexInfoKHR(const RenderingInputAttachmentIndexInfoKHR& copy_src);
+    RenderingInputAttachmentIndexInfoKHR& operator=(const RenderingInputAttachmentIndexInfoKHR& copy_src);
+    RenderingInputAttachmentIndexInfoKHR();
+    ~RenderingInputAttachmentIndexInfoKHR();
+    void initialize(const VkRenderingInputAttachmentIndexInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderingInputAttachmentIndexInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingInputAttachmentIndexInfoKHR* ptr() { return reinterpret_cast<VkRenderingInputAttachmentIndexInfoKHR*>(this); }
+    VkRenderingInputAttachmentIndexInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRenderingInputAttachmentIndexInfoKHR const*>(this);
+    }
+};
+struct PhysicalDeviceShaderQuadControlFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderQuadControl;
+
+    PhysicalDeviceShaderQuadControlFeaturesKHR(const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderQuadControlFeaturesKHR(const PhysicalDeviceShaderQuadControlFeaturesKHR& copy_src);
+    PhysicalDeviceShaderQuadControlFeaturesKHR& operator=(const PhysicalDeviceShaderQuadControlFeaturesKHR& copy_src);
+    PhysicalDeviceShaderQuadControlFeaturesKHR();
+    ~PhysicalDeviceShaderQuadControlFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderQuadControlFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderQuadControlFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderQuadControlFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderQuadControlFeaturesKHR const*>(this);
+    }
+};
+struct SurfaceProtectedCapabilitiesKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 supportsProtected;
+
+    SurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    SurfaceProtectedCapabilitiesKHR(const SurfaceProtectedCapabilitiesKHR& copy_src);
+    SurfaceProtectedCapabilitiesKHR& operator=(const SurfaceProtectedCapabilitiesKHR& copy_src);
+    SurfaceProtectedCapabilitiesKHR();
+    ~SurfaceProtectedCapabilitiesKHR();
+    void initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SurfaceProtectedCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceProtectedCapabilitiesKHR* ptr() { return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(this); }
+    VkSurfaceProtectedCapabilitiesKHR const* ptr() const {
+        return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR const*>(this);
+    }
+};
+struct PhysicalDevicePresentWaitFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentWait;
+
+    PhysicalDevicePresentWaitFeaturesKHR(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDevicePresentWaitFeaturesKHR(const PhysicalDevicePresentWaitFeaturesKHR& copy_src);
+    PhysicalDevicePresentWaitFeaturesKHR& operator=(const PhysicalDevicePresentWaitFeaturesKHR& copy_src);
+    PhysicalDevicePresentWaitFeaturesKHR();
+    ~PhysicalDevicePresentWaitFeaturesKHR();
+    void initialize(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePresentWaitFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePresentWaitFeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(this); }
+    VkPhysicalDevicePresentWaitFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineExecutableInfo;
+
+    PhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src);
+    PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=(
+        const PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src);
+    PhysicalDevicePipelineExecutablePropertiesFeaturesKHR();
+    ~PhysicalDevicePipelineExecutablePropertiesFeaturesKHR();
+    void initialize(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(this);
+    }
+    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const*>(this);
+    }
+};
+struct PipelineInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipeline pipeline;
+
+    PipelineInfoKHR(const VkPipelineInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineInfoKHR(const PipelineInfoKHR& copy_src);
+    PipelineInfoKHR& operator=(const PipelineInfoKHR& copy_src);
+    PipelineInfoKHR();
+    ~PipelineInfoKHR();
+    void initialize(const VkPipelineInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineInfoKHR* ptr() { return reinterpret_cast<VkPipelineInfoKHR*>(this); }
+    VkPipelineInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineInfoKHR const*>(this); }
+};
+struct PipelineExecutablePropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkShaderStageFlags stages;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    uint32_t subgroupSize;
+
+    PipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    PipelineExecutablePropertiesKHR(const PipelineExecutablePropertiesKHR& copy_src);
+    PipelineExecutablePropertiesKHR& operator=(const PipelineExecutablePropertiesKHR& copy_src);
+    PipelineExecutablePropertiesKHR();
+    ~PipelineExecutablePropertiesKHR();
+    void initialize(const VkPipelineExecutablePropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineExecutablePropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineExecutablePropertiesKHR* ptr() { return reinterpret_cast<VkPipelineExecutablePropertiesKHR*>(this); }
+    VkPipelineExecutablePropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineExecutablePropertiesKHR const*>(this);
+    }
+};
+struct PipelineExecutableInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipeline pipeline;
+    uint32_t executableIndex;
+
+    PipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    PipelineExecutableInfoKHR(const PipelineExecutableInfoKHR& copy_src);
+    PipelineExecutableInfoKHR& operator=(const PipelineExecutableInfoKHR& copy_src);
+    PipelineExecutableInfoKHR();
+    ~PipelineExecutableInfoKHR();
+    void initialize(const VkPipelineExecutableInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineExecutableInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineExecutableInfoKHR* ptr() { return reinterpret_cast<VkPipelineExecutableInfoKHR*>(this); }
+    VkPipelineExecutableInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineExecutableInfoKHR const*>(this); }
+};
+struct PipelineExecutableStatisticKHR {
+    VkStructureType sType;
+    void* pNext{};
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkPipelineExecutableStatisticFormatKHR format;
+    VkPipelineExecutableStatisticValueKHR value;
+
+    PipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    PipelineExecutableStatisticKHR(const PipelineExecutableStatisticKHR& copy_src);
+    PipelineExecutableStatisticKHR& operator=(const PipelineExecutableStatisticKHR& copy_src);
+    PipelineExecutableStatisticKHR();
+    ~PipelineExecutableStatisticKHR();
+    void initialize(const VkPipelineExecutableStatisticKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineExecutableStatisticKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineExecutableStatisticKHR* ptr() { return reinterpret_cast<VkPipelineExecutableStatisticKHR*>(this); }
+    VkPipelineExecutableStatisticKHR const* ptr() const { return reinterpret_cast<VkPipelineExecutableStatisticKHR const*>(this); }
+};
+struct PipelineExecutableInternalRepresentationKHR {
+    VkStructureType sType;
+    void* pNext{};
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkBool32 isText;
+    size_t dataSize;
+    void* pData{};
+
+    PipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineExecutableInternalRepresentationKHR(const PipelineExecutableInternalRepresentationKHR& copy_src);
+    PipelineExecutableInternalRepresentationKHR& operator=(const PipelineExecutableInternalRepresentationKHR& copy_src);
+    PipelineExecutableInternalRepresentationKHR();
+    ~PipelineExecutableInternalRepresentationKHR();
+    void initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineExecutableInternalRepresentationKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineExecutableInternalRepresentationKHR* ptr() {
+        return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>(this);
+    }
+    VkPipelineExecutableInternalRepresentationKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR const*>(this);
+    }
+};
+struct MemoryMapInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMemoryMapFlags flags;
+    VkDeviceMemory memory;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+
+    MemoryMapInfoKHR(const VkMemoryMapInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryMapInfoKHR(const MemoryMapInfoKHR& copy_src);
+    MemoryMapInfoKHR& operator=(const MemoryMapInfoKHR& copy_src);
+    MemoryMapInfoKHR();
+    ~MemoryMapInfoKHR();
+    void initialize(const VkMemoryMapInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryMapInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryMapInfoKHR* ptr() { return reinterpret_cast<VkMemoryMapInfoKHR*>(this); }
+    VkMemoryMapInfoKHR const* ptr() const { return reinterpret_cast<VkMemoryMapInfoKHR const*>(this); }
+};
+struct MemoryUnmapInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMemoryUnmapFlagsKHR flags;
+    VkDeviceMemory memory;
+
+    MemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryUnmapInfoKHR(const MemoryUnmapInfoKHR& copy_src);
+    MemoryUnmapInfoKHR& operator=(const MemoryUnmapInfoKHR& copy_src);
+    MemoryUnmapInfoKHR();
+    ~MemoryUnmapInfoKHR();
+    void initialize(const VkMemoryUnmapInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryUnmapInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryUnmapInfoKHR* ptr() { return reinterpret_cast<VkMemoryUnmapInfoKHR*>(this); }
+    VkMemoryUnmapInfoKHR const* ptr() const { return reinterpret_cast<VkMemoryUnmapInfoKHR const*>(this); }
+};
+struct PipelineLibraryCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t libraryCount;
+    VkPipeline* pLibraries{};
+
+    PipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    PipelineLibraryCreateInfoKHR(const PipelineLibraryCreateInfoKHR& copy_src);
+    PipelineLibraryCreateInfoKHR& operator=(const PipelineLibraryCreateInfoKHR& copy_src);
+    PipelineLibraryCreateInfoKHR();
+    ~PipelineLibraryCreateInfoKHR();
+    void initialize(const VkPipelineLibraryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineLibraryCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineLibraryCreateInfoKHR* ptr() { return reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(this); }
+    VkPipelineLibraryCreateInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineLibraryCreateInfoKHR const*>(this); }
+};
+struct PresentIdKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    const uint64_t* pPresentIds{};
+
+    PresentIdKHR(const VkPresentIdKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PresentIdKHR(const PresentIdKHR& copy_src);
+    PresentIdKHR& operator=(const PresentIdKHR& copy_src);
+    PresentIdKHR();
+    ~PresentIdKHR();
+    void initialize(const VkPresentIdKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PresentIdKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPresentIdKHR* ptr() { return reinterpret_cast<VkPresentIdKHR*>(this); }
+    VkPresentIdKHR const* ptr() const { return reinterpret_cast<VkPresentIdKHR const*>(this); }
+};
+struct PhysicalDevicePresentIdFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentId;
+
+    PhysicalDevicePresentIdFeaturesKHR(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    PhysicalDevicePresentIdFeaturesKHR(const PhysicalDevicePresentIdFeaturesKHR& copy_src);
+    PhysicalDevicePresentIdFeaturesKHR& operator=(const PhysicalDevicePresentIdFeaturesKHR& copy_src);
+    PhysicalDevicePresentIdFeaturesKHR();
+    ~PhysicalDevicePresentIdFeaturesKHR();
+    void initialize(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePresentIdFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePresentIdFeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(this); }
+    VkPhysicalDevicePresentIdFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR const*>(this);
+    }
+};
+struct VideoEncodeInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeFlagsKHR flags;
+    VkBuffer dstBuffer;
+    VkDeviceSize dstBufferOffset;
+    VkDeviceSize dstBufferRange;
+    VideoPictureResourceInfoKHR srcPictureResource;
+    VideoReferenceSlotInfoKHR* pSetupReferenceSlot{};
+    uint32_t referenceSlotCount;
+    VideoReferenceSlotInfoKHR* pReferenceSlots{};
+    uint32_t precedingExternallyEncodedBytes;
+
+    VideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeInfoKHR(const VideoEncodeInfoKHR& copy_src);
+    VideoEncodeInfoKHR& operator=(const VideoEncodeInfoKHR& copy_src);
+    VideoEncodeInfoKHR();
+    ~VideoEncodeInfoKHR();
+    void initialize(const VkVideoEncodeInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeInfoKHR*>(this); }
+    VkVideoEncodeInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeInfoKHR const*>(this); }
+};
+struct VideoEncodeCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeCapabilityFlagsKHR flags;
+    VkVideoEncodeRateControlModeFlagsKHR rateControlModes;
+    uint32_t maxRateControlLayers;
+    uint64_t maxBitrate;
+    uint32_t maxQualityLevels;
+    VkExtent2D encodeInputPictureGranularity;
+    VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags;
+
+    VideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    VideoEncodeCapabilitiesKHR(const VideoEncodeCapabilitiesKHR& copy_src);
+    VideoEncodeCapabilitiesKHR& operator=(const VideoEncodeCapabilitiesKHR& copy_src);
+    VideoEncodeCapabilitiesKHR();
+    ~VideoEncodeCapabilitiesKHR();
+    void initialize(const VkVideoEncodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeCapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeCapabilitiesKHR*>(this); }
+    VkVideoEncodeCapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeCapabilitiesKHR const*>(this); }
+};
+struct QueryPoolVideoEncodeFeedbackCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags;
+
+    QueryPoolVideoEncodeFeedbackCreateInfoKHR(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    QueryPoolVideoEncodeFeedbackCreateInfoKHR(const QueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src);
+    QueryPoolVideoEncodeFeedbackCreateInfoKHR& operator=(const QueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src);
+    QueryPoolVideoEncodeFeedbackCreateInfoKHR();
+    ~QueryPoolVideoEncodeFeedbackCreateInfoKHR();
+    void initialize(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const QueryPoolVideoEncodeFeedbackCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(this);
+    }
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeUsageInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeUsageFlagsKHR videoUsageHints;
+    VkVideoEncodeContentFlagsKHR videoContentHints;
+    VkVideoEncodeTuningModeKHR tuningMode;
+
+    VideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeUsageInfoKHR(const VideoEncodeUsageInfoKHR& copy_src);
+    VideoEncodeUsageInfoKHR& operator=(const VideoEncodeUsageInfoKHR& copy_src);
+    VideoEncodeUsageInfoKHR();
+    ~VideoEncodeUsageInfoKHR();
+    void initialize(const VkVideoEncodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeUsageInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeUsageInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeUsageInfoKHR*>(this); }
+    VkVideoEncodeUsageInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeUsageInfoKHR const*>(this); }
+};
+struct VideoEncodeRateControlLayerInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t averageBitrate;
+    uint64_t maxBitrate;
+    uint32_t frameRateNumerator;
+    uint32_t frameRateDenominator;
+
+    VideoEncodeRateControlLayerInfoKHR(const VkVideoEncodeRateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    VideoEncodeRateControlLayerInfoKHR(const VideoEncodeRateControlLayerInfoKHR& copy_src);
+    VideoEncodeRateControlLayerInfoKHR& operator=(const VideoEncodeRateControlLayerInfoKHR& copy_src);
+    VideoEncodeRateControlLayerInfoKHR();
+    ~VideoEncodeRateControlLayerInfoKHR();
+    void initialize(const VkVideoEncodeRateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeRateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeRateControlLayerInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR*>(this); }
+    VkVideoEncodeRateControlLayerInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeRateControlInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeRateControlFlagsKHR flags;
+    VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode;
+    uint32_t layerCount;
+    VideoEncodeRateControlLayerInfoKHR* pLayers{};
+    uint32_t virtualBufferSizeInMs;
+    uint32_t initialVirtualBufferSizeInMs;
+
+    VideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoEncodeRateControlInfoKHR(const VideoEncodeRateControlInfoKHR& copy_src);
+    VideoEncodeRateControlInfoKHR& operator=(const VideoEncodeRateControlInfoKHR& copy_src);
+    VideoEncodeRateControlInfoKHR();
+    ~VideoEncodeRateControlInfoKHR();
+    void initialize(const VkVideoEncodeRateControlInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeRateControlInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeRateControlInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(this); }
+    VkVideoEncodeRateControlInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeRateControlInfoKHR const*>(this); }
+};
+struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VideoProfileInfoKHR* pVideoProfile{};
+    uint32_t qualityLevel;
+
+    PhysicalDeviceVideoEncodeQualityLevelInfoKHR(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceVideoEncodeQualityLevelInfoKHR(const PhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src);
+    PhysicalDeviceVideoEncodeQualityLevelInfoKHR& operator=(const PhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src);
+    PhysicalDeviceVideoEncodeQualityLevelInfoKHR();
+    ~PhysicalDeviceVideoEncodeQualityLevelInfoKHR();
+    void initialize(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVideoEncodeQualityLevelInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*>(this);
+    }
+    VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeQualityLevelPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode;
+    uint32_t preferredRateControlLayerCount;
+
+    VideoEncodeQualityLevelPropertiesKHR(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    VideoEncodeQualityLevelPropertiesKHR(const VideoEncodeQualityLevelPropertiesKHR& copy_src);
+    VideoEncodeQualityLevelPropertiesKHR& operator=(const VideoEncodeQualityLevelPropertiesKHR& copy_src);
+    VideoEncodeQualityLevelPropertiesKHR();
+    ~VideoEncodeQualityLevelPropertiesKHR();
+    void initialize(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeQualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeQualityLevelPropertiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR*>(this); }
+    VkVideoEncodeQualityLevelPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR const*>(this);
+    }
+};
+struct VideoEncodeQualityLevelInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t qualityLevel;
+
+    VideoEncodeQualityLevelInfoKHR(const VkVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    VideoEncodeQualityLevelInfoKHR(const VideoEncodeQualityLevelInfoKHR& copy_src);
+    VideoEncodeQualityLevelInfoKHR& operator=(const VideoEncodeQualityLevelInfoKHR& copy_src);
+    VideoEncodeQualityLevelInfoKHR();
+    ~VideoEncodeQualityLevelInfoKHR();
+    void initialize(const VkVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeQualityLevelInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeQualityLevelInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeQualityLevelInfoKHR*>(this); }
+    VkVideoEncodeQualityLevelInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeQualityLevelInfoKHR const*>(this); }
+};
+struct VideoEncodeSessionParametersGetInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoSessionParametersKHR videoSessionParameters;
+
+    VideoEncodeSessionParametersGetInfoKHR(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeSessionParametersGetInfoKHR(const VideoEncodeSessionParametersGetInfoKHR& copy_src);
+    VideoEncodeSessionParametersGetInfoKHR& operator=(const VideoEncodeSessionParametersGetInfoKHR& copy_src);
+    VideoEncodeSessionParametersGetInfoKHR();
+    ~VideoEncodeSessionParametersGetInfoKHR();
+    void initialize(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeSessionParametersGetInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeSessionParametersGetInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeSessionParametersGetInfoKHR*>(this); }
+    VkVideoEncodeSessionParametersGetInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeSessionParametersGetInfoKHR const*>(this);
+    }
+};
+struct VideoEncodeSessionParametersFeedbackInfoKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hasOverrides;
+
+    VideoEncodeSessionParametersFeedbackInfoKHR(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoEncodeSessionParametersFeedbackInfoKHR(const VideoEncodeSessionParametersFeedbackInfoKHR& copy_src);
+    VideoEncodeSessionParametersFeedbackInfoKHR& operator=(const VideoEncodeSessionParametersFeedbackInfoKHR& copy_src);
+    VideoEncodeSessionParametersFeedbackInfoKHR();
+    ~VideoEncodeSessionParametersFeedbackInfoKHR();
+    void initialize(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoEncodeSessionParametersFeedbackInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeSessionParametersFeedbackInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR*>(this);
+    }
+    VkVideoEncodeSessionParametersFeedbackInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR const*>(this);
+    }
+};
+struct QueueFamilyCheckpointProperties2NV {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineStageFlags2 checkpointExecutionStageMask;
+
+    QueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    QueueFamilyCheckpointProperties2NV(const QueueFamilyCheckpointProperties2NV& copy_src);
+    QueueFamilyCheckpointProperties2NV& operator=(const QueueFamilyCheckpointProperties2NV& copy_src);
+    QueueFamilyCheckpointProperties2NV();
+    ~QueueFamilyCheckpointProperties2NV();
+    void initialize(const VkQueueFamilyCheckpointProperties2NV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const QueueFamilyCheckpointProperties2NV* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyCheckpointProperties2NV* ptr() { return reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(this); }
+    VkQueueFamilyCheckpointProperties2NV const* ptr() const {
+        return reinterpret_cast<VkQueueFamilyCheckpointProperties2NV const*>(this);
+    }
+};
+struct CheckpointData2NV {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineStageFlags2 stage;
+    void* pCheckpointMarker{};
+
+    CheckpointData2NV(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CheckpointData2NV(const CheckpointData2NV& copy_src);
+    CheckpointData2NV& operator=(const CheckpointData2NV& copy_src);
+    CheckpointData2NV();
+    ~CheckpointData2NV();
+    void initialize(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CheckpointData2NV* copy_src, PNextCopyState* copy_state = {});
+    VkCheckpointData2NV* ptr() { return reinterpret_cast<VkCheckpointData2NV*>(this); }
+    VkCheckpointData2NV const* ptr() const { return reinterpret_cast<VkCheckpointData2NV const*>(this); }
+};
+struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentShaderBarycentric;
+
+    PhysicalDeviceFragmentShaderBarycentricFeaturesKHR(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentShaderBarycentricFeaturesKHR(const PhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src);
+    PhysicalDeviceFragmentShaderBarycentricFeaturesKHR& operator=(
+        const PhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src);
+    PhysicalDeviceFragmentShaderBarycentricFeaturesKHR();
+    ~PhysicalDeviceFragmentShaderBarycentricFeaturesKHR();
+    void initialize(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentShaderBarycentricFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 triStripVertexOrderIndependentOfProvokingVertex;
+
+    PhysicalDeviceFragmentShaderBarycentricPropertiesKHR(const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentShaderBarycentricPropertiesKHR(const PhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src);
+    PhysicalDeviceFragmentShaderBarycentricPropertiesKHR& operator=(
+        const PhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src);
+    PhysicalDeviceFragmentShaderBarycentricPropertiesKHR();
+    ~PhysicalDeviceFragmentShaderBarycentricPropertiesKHR();
+    void initialize(const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentShaderBarycentricPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderSubgroupUniformControlFlow;
+
+    PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+        const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+        const PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src);
+    PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& operator=(
+        const PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src);
+    PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR();
+    ~PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 workgroupMemoryExplicitLayout;
+    VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout;
+    VkBool32 workgroupMemoryExplicitLayout8BitAccess;
+    VkBool32 workgroupMemoryExplicitLayout16BitAccess;
+
+    PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+        const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(const PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src);
+    PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& operator=(
+        const PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src);
+    PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR();
+    ~PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR();
+    void initialize(const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingMaintenance1;
+    VkBool32 rayTracingPipelineTraceRaysIndirect2;
+
+    PhysicalDeviceRayTracingMaintenance1FeaturesKHR(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRayTracingMaintenance1FeaturesKHR(const PhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src);
+    PhysicalDeviceRayTracingMaintenance1FeaturesKHR& operator=(const PhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src);
+    PhysicalDeviceRayTracingMaintenance1FeaturesKHR();
+    ~PhysicalDeviceRayTracingMaintenance1FeaturesKHR();
+    void initialize(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRayTracingMaintenance1FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceShaderSubgroupRotateFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderSubgroupRotate;
+    VkBool32 shaderSubgroupRotateClustered;
+
+    PhysicalDeviceShaderSubgroupRotateFeaturesKHR(const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderSubgroupRotateFeaturesKHR(const PhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src);
+    PhysicalDeviceShaderSubgroupRotateFeaturesKHR& operator=(const PhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src);
+    PhysicalDeviceShaderSubgroupRotateFeaturesKHR();
+    ~PhysicalDeviceShaderSubgroupRotateFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderSubgroupRotateFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderMaximalReconvergence;
+
+    PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(const PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src);
+    PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& operator=(
+        const PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src);
+    PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR();
+    ~PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceMaintenance5FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 maintenance5;
+
+    PhysicalDeviceMaintenance5FeaturesKHR(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDeviceMaintenance5FeaturesKHR(const PhysicalDeviceMaintenance5FeaturesKHR& copy_src);
+    PhysicalDeviceMaintenance5FeaturesKHR& operator=(const PhysicalDeviceMaintenance5FeaturesKHR& copy_src);
+    PhysicalDeviceMaintenance5FeaturesKHR();
+    ~PhysicalDeviceMaintenance5FeaturesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMaintenance5FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance5FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(this); }
+    VkPhysicalDeviceMaintenance5FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceMaintenance5PropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting;
+    VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting;
+    VkBool32 depthStencilSwizzleOneSupport;
+    VkBool32 polygonModePointSize;
+    VkBool32 nonStrictSinglePixelWideLinesUseParallelogram;
+    VkBool32 nonStrictWideLinesUseParallelogram;
+
+    PhysicalDeviceMaintenance5PropertiesKHR(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMaintenance5PropertiesKHR(const PhysicalDeviceMaintenance5PropertiesKHR& copy_src);
+    PhysicalDeviceMaintenance5PropertiesKHR& operator=(const PhysicalDeviceMaintenance5PropertiesKHR& copy_src);
+    PhysicalDeviceMaintenance5PropertiesKHR();
+    ~PhysicalDeviceMaintenance5PropertiesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMaintenance5PropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance5PropertiesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(this); }
+    VkPhysicalDeviceMaintenance5PropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR const*>(this);
+    }
+};
+struct RenderingAreaInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    const VkFormat* pColorAttachmentFormats{};
+    VkFormat depthAttachmentFormat;
+    VkFormat stencilAttachmentFormat;
+
+    RenderingAreaInfoKHR(const VkRenderingAreaInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderingAreaInfoKHR(const RenderingAreaInfoKHR& copy_src);
+    RenderingAreaInfoKHR& operator=(const RenderingAreaInfoKHR& copy_src);
+    RenderingAreaInfoKHR();
+    ~RenderingAreaInfoKHR();
+    void initialize(const VkRenderingAreaInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderingAreaInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingAreaInfoKHR* ptr() { return reinterpret_cast<VkRenderingAreaInfoKHR*>(this); }
+    VkRenderingAreaInfoKHR const* ptr() const { return reinterpret_cast<VkRenderingAreaInfoKHR const*>(this); }
+};
+struct ImageSubresource2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageSubresource imageSubresource;
+
+    ImageSubresource2KHR(const VkImageSubresource2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageSubresource2KHR(const ImageSubresource2KHR& copy_src);
+    ImageSubresource2KHR& operator=(const ImageSubresource2KHR& copy_src);
+    ImageSubresource2KHR();
+    ~ImageSubresource2KHR();
+    void initialize(const VkImageSubresource2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageSubresource2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkImageSubresource2KHR* ptr() { return reinterpret_cast<VkImageSubresource2KHR*>(this); }
+    VkImageSubresource2KHR const* ptr() const { return reinterpret_cast<VkImageSubresource2KHR const*>(this); }
+};
+struct DeviceImageSubresourceInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    ImageCreateInfo* pCreateInfo{};
+    ImageSubresource2KHR* pSubresource{};
+
+    DeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    DeviceImageSubresourceInfoKHR(const DeviceImageSubresourceInfoKHR& copy_src);
+    DeviceImageSubresourceInfoKHR& operator=(const DeviceImageSubresourceInfoKHR& copy_src);
+    DeviceImageSubresourceInfoKHR();
+    ~DeviceImageSubresourceInfoKHR();
+    void initialize(const VkDeviceImageSubresourceInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceImageSubresourceInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceImageSubresourceInfoKHR* ptr() { return reinterpret_cast<VkDeviceImageSubresourceInfoKHR*>(this); }
+    VkDeviceImageSubresourceInfoKHR const* ptr() const { return reinterpret_cast<VkDeviceImageSubresourceInfoKHR const*>(this); }
+};
+struct SubresourceLayout2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkSubresourceLayout subresourceLayout;
+
+    SubresourceLayout2KHR(const VkSubresourceLayout2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SubresourceLayout2KHR(const SubresourceLayout2KHR& copy_src);
+    SubresourceLayout2KHR& operator=(const SubresourceLayout2KHR& copy_src);
+    SubresourceLayout2KHR();
+    ~SubresourceLayout2KHR();
+    void initialize(const VkSubresourceLayout2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubresourceLayout2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkSubresourceLayout2KHR* ptr() { return reinterpret_cast<VkSubresourceLayout2KHR*>(this); }
+    VkSubresourceLayout2KHR const* ptr() const { return reinterpret_cast<VkSubresourceLayout2KHR const*>(this); }
+};
+struct PipelineCreateFlags2CreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags2KHR flags;
+
+    PipelineCreateFlags2CreateInfoKHR(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    PipelineCreateFlags2CreateInfoKHR(const PipelineCreateFlags2CreateInfoKHR& copy_src);
+    PipelineCreateFlags2CreateInfoKHR& operator=(const PipelineCreateFlags2CreateInfoKHR& copy_src);
+    PipelineCreateFlags2CreateInfoKHR();
+    ~PipelineCreateFlags2CreateInfoKHR();
+    void initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineCreateFlags2CreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCreateFlags2CreateInfoKHR* ptr() { return reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(this); }
+    VkPipelineCreateFlags2CreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR const*>(this);
+    }
+};
+struct BufferUsageFlags2CreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferUsageFlags2KHR usage;
+
+    BufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    BufferUsageFlags2CreateInfoKHR(const BufferUsageFlags2CreateInfoKHR& copy_src);
+    BufferUsageFlags2CreateInfoKHR& operator=(const BufferUsageFlags2CreateInfoKHR& copy_src);
+    BufferUsageFlags2CreateInfoKHR();
+    ~BufferUsageFlags2CreateInfoKHR();
+    void initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferUsageFlags2CreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkBufferUsageFlags2CreateInfoKHR* ptr() { return reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(this); }
+    VkBufferUsageFlags2CreateInfoKHR const* ptr() const { return reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR const*>(this); }
+};
+struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingPositionFetch;
+
+    PhysicalDeviceRayTracingPositionFetchFeaturesKHR(const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRayTracingPositionFetchFeaturesKHR(const PhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src);
+    PhysicalDeviceRayTracingPositionFetchFeaturesKHR& operator=(const PhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src);
+    PhysicalDeviceRayTracingPositionFetchFeaturesKHR();
+    ~PhysicalDeviceRayTracingPositionFetchFeaturesKHR();
+    void initialize(const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRayTracingPositionFetchFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const*>(this);
+    }
+};
+struct CooperativeMatrixPropertiesKHR {
+    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;
+
+    CooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    CooperativeMatrixPropertiesKHR(const CooperativeMatrixPropertiesKHR& copy_src);
+    CooperativeMatrixPropertiesKHR& operator=(const CooperativeMatrixPropertiesKHR& copy_src);
+    CooperativeMatrixPropertiesKHR();
+    ~CooperativeMatrixPropertiesKHR();
+    void initialize(const VkCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CooperativeMatrixPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkCooperativeMatrixPropertiesKHR* ptr() { return reinterpret_cast<VkCooperativeMatrixPropertiesKHR*>(this); }
+    VkCooperativeMatrixPropertiesKHR const* ptr() const { return reinterpret_cast<VkCooperativeMatrixPropertiesKHR const*>(this); }
+};
+struct PhysicalDeviceCooperativeMatrixFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cooperativeMatrix;
+    VkBool32 cooperativeMatrixRobustBufferAccess;
+
+    PhysicalDeviceCooperativeMatrixFeaturesKHR(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCooperativeMatrixFeaturesKHR(const PhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src);
+    PhysicalDeviceCooperativeMatrixFeaturesKHR& operator=(const PhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src);
+    PhysicalDeviceCooperativeMatrixFeaturesKHR();
+    ~PhysicalDeviceCooperativeMatrixFeaturesKHR();
+    void initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCooperativeMatrixFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeMatrixFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceCooperativeMatrixFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceCooperativeMatrixPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkShaderStageFlags cooperativeMatrixSupportedStages;
+
+    PhysicalDeviceCooperativeMatrixPropertiesKHR(const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCooperativeMatrixPropertiesKHR(const PhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src);
+    PhysicalDeviceCooperativeMatrixPropertiesKHR& operator=(const PhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src);
+    PhysicalDeviceCooperativeMatrixPropertiesKHR();
+    ~PhysicalDeviceCooperativeMatrixPropertiesKHR();
+    void initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCooperativeMatrixPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeMatrixPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceCooperativeMatrixPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesKHR const*>(this);
+    }
+};
+struct VideoDecodeAV1ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoAV1Profile stdProfile;
+    VkBool32 filmGrainSupport;
+
+    VideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    VideoDecodeAV1ProfileInfoKHR(const VideoDecodeAV1ProfileInfoKHR& copy_src);
+    VideoDecodeAV1ProfileInfoKHR& operator=(const VideoDecodeAV1ProfileInfoKHR& copy_src);
+    VideoDecodeAV1ProfileInfoKHR();
+    ~VideoDecodeAV1ProfileInfoKHR();
+    void initialize(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeAV1ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeAV1ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeAV1ProfileInfoKHR*>(this); }
+    VkVideoDecodeAV1ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeAV1ProfileInfoKHR const*>(this); }
+};
+struct VideoDecodeAV1CapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    StdVideoAV1Level maxLevel;
+
+    VideoDecodeAV1CapabilitiesKHR(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    VideoDecodeAV1CapabilitiesKHR(const VideoDecodeAV1CapabilitiesKHR& copy_src);
+    VideoDecodeAV1CapabilitiesKHR& operator=(const VideoDecodeAV1CapabilitiesKHR& copy_src);
+    VideoDecodeAV1CapabilitiesKHR();
+    ~VideoDecodeAV1CapabilitiesKHR();
+    void initialize(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeAV1CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeAV1CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoDecodeAV1CapabilitiesKHR*>(this); }
+    VkVideoDecodeAV1CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeAV1CapabilitiesKHR const*>(this); }
+};
+struct VideoDecodeAV1SessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoAV1SequenceHeader* pStdSequenceHeader{};
+
+    VideoDecodeAV1SessionParametersCreateInfoKHR(const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoDecodeAV1SessionParametersCreateInfoKHR(const VideoDecodeAV1SessionParametersCreateInfoKHR& copy_src);
+    VideoDecodeAV1SessionParametersCreateInfoKHR& operator=(const VideoDecodeAV1SessionParametersCreateInfoKHR& copy_src);
+    VideoDecodeAV1SessionParametersCreateInfoKHR();
+    ~VideoDecodeAV1SessionParametersCreateInfoKHR();
+    void initialize(const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeAV1SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeAV1SessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeAV1SessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoDecodeAV1SessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeAV1SessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct VideoDecodeAV1PictureInfoKHR {
+    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{};
+
+    VideoDecodeAV1PictureInfoKHR(const VkVideoDecodeAV1PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    VideoDecodeAV1PictureInfoKHR(const VideoDecodeAV1PictureInfoKHR& copy_src);
+    VideoDecodeAV1PictureInfoKHR& operator=(const VideoDecodeAV1PictureInfoKHR& copy_src);
+    VideoDecodeAV1PictureInfoKHR();
+    ~VideoDecodeAV1PictureInfoKHR();
+    void initialize(const VkVideoDecodeAV1PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeAV1PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeAV1PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeAV1PictureInfoKHR*>(this); }
+    VkVideoDecodeAV1PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeAV1PictureInfoKHR const*>(this); }
+};
+struct VideoDecodeAV1DpbSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo{};
+
+    VideoDecodeAV1DpbSlotInfoKHR(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    VideoDecodeAV1DpbSlotInfoKHR(const VideoDecodeAV1DpbSlotInfoKHR& copy_src);
+    VideoDecodeAV1DpbSlotInfoKHR& operator=(const VideoDecodeAV1DpbSlotInfoKHR& copy_src);
+    VideoDecodeAV1DpbSlotInfoKHR();
+    ~VideoDecodeAV1DpbSlotInfoKHR();
+    void initialize(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoDecodeAV1DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeAV1DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeAV1DpbSlotInfoKHR*>(this); }
+    VkVideoDecodeAV1DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeAV1DpbSlotInfoKHR const*>(this); }
+};
+struct PhysicalDeviceVideoMaintenance1FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 videoMaintenance1;
+
+    PhysicalDeviceVideoMaintenance1FeaturesKHR(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceVideoMaintenance1FeaturesKHR(const PhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src);
+    PhysicalDeviceVideoMaintenance1FeaturesKHR& operator=(const PhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src);
+    PhysicalDeviceVideoMaintenance1FeaturesKHR();
+    ~PhysicalDeviceVideoMaintenance1FeaturesKHR();
+    void initialize(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVideoMaintenance1FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVideoMaintenance1FeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceVideoMaintenance1FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVideoMaintenance1FeaturesKHR const*>(this);
+    }
+};
+struct VideoInlineQueryInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueryPool queryPool;
+    uint32_t firstQuery;
+    uint32_t queryCount;
+
+    VideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    VideoInlineQueryInfoKHR(const VideoInlineQueryInfoKHR& copy_src);
+    VideoInlineQueryInfoKHR& operator=(const VideoInlineQueryInfoKHR& copy_src);
+    VideoInlineQueryInfoKHR();
+    ~VideoInlineQueryInfoKHR();
+    void initialize(const VkVideoInlineQueryInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VideoInlineQueryInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoInlineQueryInfoKHR* ptr() { return reinterpret_cast<VkVideoInlineQueryInfoKHR*>(this); }
+    VkVideoInlineQueryInfoKHR const* ptr() const { return reinterpret_cast<VkVideoInlineQueryInfoKHR const*>(this); }
+};
+struct PhysicalDeviceVertexAttributeDivisorPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxVertexAttribDivisor;
+    VkBool32 supportsNonZeroFirstInstance;
+
+    PhysicalDeviceVertexAttributeDivisorPropertiesKHR(const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceVertexAttributeDivisorPropertiesKHR(const PhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src);
+    PhysicalDeviceVertexAttributeDivisorPropertiesKHR& operator=(const PhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src);
+    PhysicalDeviceVertexAttributeDivisorPropertiesKHR();
+    ~PhysicalDeviceVertexAttributeDivisorPropertiesKHR();
+    void initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR const*>(this);
+    }
+};
+struct PipelineVertexInputDivisorStateCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t vertexBindingDivisorCount;
+    const VkVertexInputBindingDivisorDescriptionKHR* pVertexBindingDivisors{};
+
+    PipelineVertexInputDivisorStateCreateInfoKHR(const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineVertexInputDivisorStateCreateInfoKHR(const PipelineVertexInputDivisorStateCreateInfoKHR& copy_src);
+    PipelineVertexInputDivisorStateCreateInfoKHR& operator=(const PipelineVertexInputDivisorStateCreateInfoKHR& copy_src);
+    PipelineVertexInputDivisorStateCreateInfoKHR();
+    ~PipelineVertexInputDivisorStateCreateInfoKHR();
+    void initialize(const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineVertexInputDivisorStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineVertexInputDivisorStateCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoKHR*>(this);
+    }
+    VkPipelineVertexInputDivisorStateCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoKHR const*>(this);
+    }
+};
+struct PhysicalDeviceVertexAttributeDivisorFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 vertexAttributeInstanceRateDivisor;
+    VkBool32 vertexAttributeInstanceRateZeroDivisor;
+
+    PhysicalDeviceVertexAttributeDivisorFeaturesKHR(const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceVertexAttributeDivisorFeaturesKHR(const PhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src);
+    PhysicalDeviceVertexAttributeDivisorFeaturesKHR& operator=(const PhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src);
+    PhysicalDeviceVertexAttributeDivisorFeaturesKHR();
+    ~PhysicalDeviceVertexAttributeDivisorFeaturesKHR();
+    void initialize(const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceShaderFloatControls2FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderFloatControls2;
+
+    PhysicalDeviceShaderFloatControls2FeaturesKHR(const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderFloatControls2FeaturesKHR(const PhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src);
+    PhysicalDeviceShaderFloatControls2FeaturesKHR& operator=(const PhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src);
+    PhysicalDeviceShaderFloatControls2FeaturesKHR();
+    ~PhysicalDeviceShaderFloatControls2FeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderFloatControls2FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderFloatControls2FeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderFloatControls2FeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderFloatControls2FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderFloatControls2FeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceIndexTypeUint8FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 indexTypeUint8;
+
+    PhysicalDeviceIndexTypeUint8FeaturesKHR(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceIndexTypeUint8FeaturesKHR(const PhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src);
+    PhysicalDeviceIndexTypeUint8FeaturesKHR& operator=(const PhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src);
+    PhysicalDeviceIndexTypeUint8FeaturesKHR();
+    ~PhysicalDeviceIndexTypeUint8FeaturesKHR();
+    void initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceIndexTypeUint8FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceIndexTypeUint8FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesKHR*>(this); }
+    VkPhysicalDeviceIndexTypeUint8FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceLineRasterizationFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rectangularLines;
+    VkBool32 bresenhamLines;
+    VkBool32 smoothLines;
+    VkBool32 stippledRectangularLines;
+    VkBool32 stippledBresenhamLines;
+    VkBool32 stippledSmoothLines;
+
+    PhysicalDeviceLineRasterizationFeaturesKHR(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceLineRasterizationFeaturesKHR(const PhysicalDeviceLineRasterizationFeaturesKHR& copy_src);
+    PhysicalDeviceLineRasterizationFeaturesKHR& operator=(const PhysicalDeviceLineRasterizationFeaturesKHR& copy_src);
+    PhysicalDeviceLineRasterizationFeaturesKHR();
+    ~PhysicalDeviceLineRasterizationFeaturesKHR();
+    void initialize(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceLineRasterizationFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLineRasterizationFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceLineRasterizationFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceLineRasterizationPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t lineSubPixelPrecisionBits;
+
+    PhysicalDeviceLineRasterizationPropertiesKHR(const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceLineRasterizationPropertiesKHR(const PhysicalDeviceLineRasterizationPropertiesKHR& copy_src);
+    PhysicalDeviceLineRasterizationPropertiesKHR& operator=(const PhysicalDeviceLineRasterizationPropertiesKHR& copy_src);
+    PhysicalDeviceLineRasterizationPropertiesKHR();
+    ~PhysicalDeviceLineRasterizationPropertiesKHR();
+    void initialize(const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceLineRasterizationPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLineRasterizationPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceLineRasterizationPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesKHR const*>(this);
+    }
+};
+struct PipelineRasterizationLineStateCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkLineRasterizationModeKHR lineRasterizationMode;
+    VkBool32 stippledLineEnable;
+    uint32_t lineStippleFactor;
+    uint16_t lineStipplePattern;
+
+    PipelineRasterizationLineStateCreateInfoKHR(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineRasterizationLineStateCreateInfoKHR(const PipelineRasterizationLineStateCreateInfoKHR& copy_src);
+    PipelineRasterizationLineStateCreateInfoKHR& operator=(const PipelineRasterizationLineStateCreateInfoKHR& copy_src);
+    PipelineRasterizationLineStateCreateInfoKHR();
+    ~PipelineRasterizationLineStateCreateInfoKHR();
+    void initialize(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineRasterizationLineStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationLineStateCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoKHR*>(this);
+    }
+    VkPipelineRasterizationLineStateCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoKHR const*>(this);
+    }
+};
+struct CalibratedTimestampInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTimeDomainKHR timeDomain;
+
+    CalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    CalibratedTimestampInfoKHR(const CalibratedTimestampInfoKHR& copy_src);
+    CalibratedTimestampInfoKHR& operator=(const CalibratedTimestampInfoKHR& copy_src);
+    CalibratedTimestampInfoKHR();
+    ~CalibratedTimestampInfoKHR();
+    void initialize(const VkCalibratedTimestampInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CalibratedTimestampInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkCalibratedTimestampInfoKHR* ptr() { return reinterpret_cast<VkCalibratedTimestampInfoKHR*>(this); }
+    VkCalibratedTimestampInfoKHR const* ptr() const { return reinterpret_cast<VkCalibratedTimestampInfoKHR const*>(this); }
+};
+struct PhysicalDeviceShaderExpectAssumeFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderExpectAssume;
+
+    PhysicalDeviceShaderExpectAssumeFeaturesKHR(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderExpectAssumeFeaturesKHR(const PhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src);
+    PhysicalDeviceShaderExpectAssumeFeaturesKHR& operator=(const PhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src);
+    PhysicalDeviceShaderExpectAssumeFeaturesKHR();
+    ~PhysicalDeviceShaderExpectAssumeFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderExpectAssumeFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderExpectAssumeFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceMaintenance6FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 maintenance6;
+
+    PhysicalDeviceMaintenance6FeaturesKHR(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDeviceMaintenance6FeaturesKHR(const PhysicalDeviceMaintenance6FeaturesKHR& copy_src);
+    PhysicalDeviceMaintenance6FeaturesKHR& operator=(const PhysicalDeviceMaintenance6FeaturesKHR& copy_src);
+    PhysicalDeviceMaintenance6FeaturesKHR();
+    ~PhysicalDeviceMaintenance6FeaturesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMaintenance6FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance6FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance6FeaturesKHR*>(this); }
+    VkPhysicalDeviceMaintenance6FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance6FeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceMaintenance6PropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 blockTexelViewCompatibleMultipleLayers;
+    uint32_t maxCombinedImageSamplerDescriptorCount;
+    VkBool32 fragmentShadingRateClampCombinerInputs;
+
+    PhysicalDeviceMaintenance6PropertiesKHR(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMaintenance6PropertiesKHR(const PhysicalDeviceMaintenance6PropertiesKHR& copy_src);
+    PhysicalDeviceMaintenance6PropertiesKHR& operator=(const PhysicalDeviceMaintenance6PropertiesKHR& copy_src);
+    PhysicalDeviceMaintenance6PropertiesKHR();
+    ~PhysicalDeviceMaintenance6PropertiesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMaintenance6PropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance6PropertiesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance6PropertiesKHR*>(this); }
+    VkPhysicalDeviceMaintenance6PropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance6PropertiesKHR const*>(this);
+    }
+};
+struct BindMemoryStatusKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkResult* pResult{};
+
+    BindMemoryStatusKHR(const VkBindMemoryStatusKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BindMemoryStatusKHR(const BindMemoryStatusKHR& copy_src);
+    BindMemoryStatusKHR& operator=(const BindMemoryStatusKHR& copy_src);
+    BindMemoryStatusKHR();
+    ~BindMemoryStatusKHR();
+    void initialize(const VkBindMemoryStatusKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindMemoryStatusKHR* copy_src, PNextCopyState* copy_state = {});
+    VkBindMemoryStatusKHR* ptr() { return reinterpret_cast<VkBindMemoryStatusKHR*>(this); }
+    VkBindMemoryStatusKHR const* ptr() const { return reinterpret_cast<VkBindMemoryStatusKHR const*>(this); }
+};
+struct BindDescriptorSetsInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout layout;
+    uint32_t firstSet;
+    uint32_t descriptorSetCount;
+    VkDescriptorSet* pDescriptorSets{};
+    uint32_t dynamicOffsetCount;
+    const uint32_t* pDynamicOffsets{};
+
+    BindDescriptorSetsInfoKHR(const VkBindDescriptorSetsInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    BindDescriptorSetsInfoKHR(const BindDescriptorSetsInfoKHR& copy_src);
+    BindDescriptorSetsInfoKHR& operator=(const BindDescriptorSetsInfoKHR& copy_src);
+    BindDescriptorSetsInfoKHR();
+    ~BindDescriptorSetsInfoKHR();
+    void initialize(const VkBindDescriptorSetsInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindDescriptorSetsInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkBindDescriptorSetsInfoKHR* ptr() { return reinterpret_cast<VkBindDescriptorSetsInfoKHR*>(this); }
+    VkBindDescriptorSetsInfoKHR const* ptr() const { return reinterpret_cast<VkBindDescriptorSetsInfoKHR const*>(this); }
+};
+struct PushConstantsInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineLayout layout;
+    VkShaderStageFlags stageFlags;
+    uint32_t offset;
+    uint32_t size;
+    const void* pValues{};
+
+    PushConstantsInfoKHR(const VkPushConstantsInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PushConstantsInfoKHR(const PushConstantsInfoKHR& copy_src);
+    PushConstantsInfoKHR& operator=(const PushConstantsInfoKHR& copy_src);
+    PushConstantsInfoKHR();
+    ~PushConstantsInfoKHR();
+    void initialize(const VkPushConstantsInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PushConstantsInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPushConstantsInfoKHR* ptr() { return reinterpret_cast<VkPushConstantsInfoKHR*>(this); }
+    VkPushConstantsInfoKHR const* ptr() const { return reinterpret_cast<VkPushConstantsInfoKHR const*>(this); }
+};
+struct PushDescriptorSetInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout layout;
+    uint32_t set;
+    uint32_t descriptorWriteCount;
+    WriteDescriptorSet* pDescriptorWrites{};
+
+    PushDescriptorSetInfoKHR(const VkPushDescriptorSetInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PushDescriptorSetInfoKHR(const PushDescriptorSetInfoKHR& copy_src);
+    PushDescriptorSetInfoKHR& operator=(const PushDescriptorSetInfoKHR& copy_src);
+    PushDescriptorSetInfoKHR();
+    ~PushDescriptorSetInfoKHR();
+    void initialize(const VkPushDescriptorSetInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PushDescriptorSetInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPushDescriptorSetInfoKHR* ptr() { return reinterpret_cast<VkPushDescriptorSetInfoKHR*>(this); }
+    VkPushDescriptorSetInfoKHR const* ptr() const { return reinterpret_cast<VkPushDescriptorSetInfoKHR const*>(this); }
+};
+struct PushDescriptorSetWithTemplateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate;
+    VkPipelineLayout layout;
+    uint32_t set;
+    const void* pData{};
+
+    PushDescriptorSetWithTemplateInfoKHR(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PushDescriptorSetWithTemplateInfoKHR(const PushDescriptorSetWithTemplateInfoKHR& copy_src);
+    PushDescriptorSetWithTemplateInfoKHR& operator=(const PushDescriptorSetWithTemplateInfoKHR& copy_src);
+    PushDescriptorSetWithTemplateInfoKHR();
+    ~PushDescriptorSetWithTemplateInfoKHR();
+    void initialize(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PushDescriptorSetWithTemplateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPushDescriptorSetWithTemplateInfoKHR* ptr() { return reinterpret_cast<VkPushDescriptorSetWithTemplateInfoKHR*>(this); }
+    VkPushDescriptorSetWithTemplateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPushDescriptorSetWithTemplateInfoKHR const*>(this);
+    }
+};
+struct SetDescriptorBufferOffsetsInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout layout;
+    uint32_t firstSet;
+    uint32_t setCount;
+    const uint32_t* pBufferIndices{};
+    const VkDeviceSize* pOffsets{};
+
+    SetDescriptorBufferOffsetsInfoEXT(const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    SetDescriptorBufferOffsetsInfoEXT(const SetDescriptorBufferOffsetsInfoEXT& copy_src);
+    SetDescriptorBufferOffsetsInfoEXT& operator=(const SetDescriptorBufferOffsetsInfoEXT& copy_src);
+    SetDescriptorBufferOffsetsInfoEXT();
+    ~SetDescriptorBufferOffsetsInfoEXT();
+    void initialize(const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SetDescriptorBufferOffsetsInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSetDescriptorBufferOffsetsInfoEXT* ptr() { return reinterpret_cast<VkSetDescriptorBufferOffsetsInfoEXT*>(this); }
+    VkSetDescriptorBufferOffsetsInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSetDescriptorBufferOffsetsInfoEXT const*>(this);
+    }
+};
+struct BindDescriptorBufferEmbeddedSamplersInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout layout;
+    uint32_t set;
+
+    BindDescriptorBufferEmbeddedSamplersInfoEXT(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BindDescriptorBufferEmbeddedSamplersInfoEXT(const BindDescriptorBufferEmbeddedSamplersInfoEXT& copy_src);
+    BindDescriptorBufferEmbeddedSamplersInfoEXT& operator=(const BindDescriptorBufferEmbeddedSamplersInfoEXT& copy_src);
+    BindDescriptorBufferEmbeddedSamplersInfoEXT();
+    ~BindDescriptorBufferEmbeddedSamplersInfoEXT();
+    void initialize(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindDescriptorBufferEmbeddedSamplersInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkBindDescriptorBufferEmbeddedSamplersInfoEXT* ptr() {
+        return reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT*>(this);
+    }
+    VkBindDescriptorBufferEmbeddedSamplersInfoEXT const* ptr() const {
+        return reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT const*>(this);
+    }
+};
+struct DebugReportCallbackCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDebugReportFlagsEXT flags;
+    PFN_vkDebugReportCallbackEXT pfnCallback;
+    void* pUserData{};
+
+    DebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    DebugReportCallbackCreateInfoEXT(const DebugReportCallbackCreateInfoEXT& copy_src);
+    DebugReportCallbackCreateInfoEXT& operator=(const DebugReportCallbackCreateInfoEXT& copy_src);
+    DebugReportCallbackCreateInfoEXT();
+    ~DebugReportCallbackCreateInfoEXT();
+    void initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DebugReportCallbackCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugReportCallbackCreateInfoEXT* ptr() { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this); }
+    VkDebugReportCallbackCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT const*>(this);
+    }
+};
+struct PipelineRasterizationStateRasterizationOrderAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRasterizationOrderAMD rasterizationOrder;
+
+    PipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineRasterizationStateRasterizationOrderAMD(const PipelineRasterizationStateRasterizationOrderAMD& copy_src);
+    PipelineRasterizationStateRasterizationOrderAMD& operator=(const PipelineRasterizationStateRasterizationOrderAMD& copy_src);
+    PipelineRasterizationStateRasterizationOrderAMD();
+    ~PipelineRasterizationStateRasterizationOrderAMD();
+    void initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineRasterizationStateRasterizationOrderAMD* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationStateRasterizationOrderAMD* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
+    }
+    VkPipelineRasterizationStateRasterizationOrderAMD const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD const*>(this);
+    }
+};
+struct DebugMarkerObjectNameInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDebugReportObjectTypeEXT objectType;
+    uint64_t object;
+    const char* pObjectName{};
+
+    DebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    DebugMarkerObjectNameInfoEXT(const DebugMarkerObjectNameInfoEXT& copy_src);
+    DebugMarkerObjectNameInfoEXT& operator=(const DebugMarkerObjectNameInfoEXT& copy_src);
+    DebugMarkerObjectNameInfoEXT();
+    ~DebugMarkerObjectNameInfoEXT();
+    void initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DebugMarkerObjectNameInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugMarkerObjectNameInfoEXT* ptr() { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this); }
+    VkDebugMarkerObjectNameInfoEXT const* ptr() const { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT const*>(this); }
+};
+struct DebugMarkerObjectTagInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDebugReportObjectTypeEXT objectType;
+    uint64_t object;
+    uint64_t tagName;
+    size_t tagSize;
+    const void* pTag{};
+
+    DebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    DebugMarkerObjectTagInfoEXT(const DebugMarkerObjectTagInfoEXT& copy_src);
+    DebugMarkerObjectTagInfoEXT& operator=(const DebugMarkerObjectTagInfoEXT& copy_src);
+    DebugMarkerObjectTagInfoEXT();
+    ~DebugMarkerObjectTagInfoEXT();
+    void initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DebugMarkerObjectTagInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugMarkerObjectTagInfoEXT* ptr() { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this); }
+    VkDebugMarkerObjectTagInfoEXT const* ptr() const { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT const*>(this); }
+};
+struct DebugMarkerMarkerInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    const char* pMarkerName{};
+    float color[4];
+
+    DebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DebugMarkerMarkerInfoEXT(const DebugMarkerMarkerInfoEXT& copy_src);
+    DebugMarkerMarkerInfoEXT& operator=(const DebugMarkerMarkerInfoEXT& copy_src);
+    DebugMarkerMarkerInfoEXT();
+    ~DebugMarkerMarkerInfoEXT();
+    void initialize(const VkDebugMarkerMarkerInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DebugMarkerMarkerInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugMarkerMarkerInfoEXT* ptr() { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this); }
+    VkDebugMarkerMarkerInfoEXT const* ptr() const { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT const*>(this); }
+};
+struct DedicatedAllocationImageCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 dedicatedAllocation;
+
+    DedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    DedicatedAllocationImageCreateInfoNV(const DedicatedAllocationImageCreateInfoNV& copy_src);
+    DedicatedAllocationImageCreateInfoNV& operator=(const DedicatedAllocationImageCreateInfoNV& copy_src);
+    DedicatedAllocationImageCreateInfoNV();
+    ~DedicatedAllocationImageCreateInfoNV();
+    void initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DedicatedAllocationImageCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkDedicatedAllocationImageCreateInfoNV* ptr() { return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this); }
+    VkDedicatedAllocationImageCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV const*>(this);
+    }
+};
+struct DedicatedAllocationBufferCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 dedicatedAllocation;
+
+    DedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    DedicatedAllocationBufferCreateInfoNV(const DedicatedAllocationBufferCreateInfoNV& copy_src);
+    DedicatedAllocationBufferCreateInfoNV& operator=(const DedicatedAllocationBufferCreateInfoNV& copy_src);
+    DedicatedAllocationBufferCreateInfoNV();
+    ~DedicatedAllocationBufferCreateInfoNV();
+    void initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DedicatedAllocationBufferCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkDedicatedAllocationBufferCreateInfoNV* ptr() { return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this); }
+    VkDedicatedAllocationBufferCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV const*>(this);
+    }
+};
+struct DedicatedAllocationMemoryAllocateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    VkBuffer buffer;
+
+    DedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DedicatedAllocationMemoryAllocateInfoNV(const DedicatedAllocationMemoryAllocateInfoNV& copy_src);
+    DedicatedAllocationMemoryAllocateInfoNV& operator=(const DedicatedAllocationMemoryAllocateInfoNV& copy_src);
+    DedicatedAllocationMemoryAllocateInfoNV();
+    ~DedicatedAllocationMemoryAllocateInfoNV();
+    void initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DedicatedAllocationMemoryAllocateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkDedicatedAllocationMemoryAllocateInfoNV* ptr() { return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this); }
+    VkDedicatedAllocationMemoryAllocateInfoNV const* ptr() const {
+        return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceTransformFeedbackFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 transformFeedback;
+    VkBool32 geometryStreams;
+
+    PhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceTransformFeedbackFeaturesEXT(const PhysicalDeviceTransformFeedbackFeaturesEXT& copy_src);
+    PhysicalDeviceTransformFeedbackFeaturesEXT& operator=(const PhysicalDeviceTransformFeedbackFeaturesEXT& copy_src);
+    PhysicalDeviceTransformFeedbackFeaturesEXT();
+    ~PhysicalDeviceTransformFeedbackFeaturesEXT();
+    void initialize(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceTransformFeedbackFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTransformFeedbackFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceTransformFeedbackFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceTransformFeedbackPropertiesEXT {
+    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;
+
+    PhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceTransformFeedbackPropertiesEXT(const PhysicalDeviceTransformFeedbackPropertiesEXT& copy_src);
+    PhysicalDeviceTransformFeedbackPropertiesEXT& operator=(const PhysicalDeviceTransformFeedbackPropertiesEXT& copy_src);
+    PhysicalDeviceTransformFeedbackPropertiesEXT();
+    ~PhysicalDeviceTransformFeedbackPropertiesEXT();
+    void initialize(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceTransformFeedbackPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTransformFeedbackPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceTransformFeedbackPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT const*>(this);
+    }
+};
+struct PipelineRasterizationStateStreamCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
+    uint32_t rasterizationStream;
+
+    PipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineRasterizationStateStreamCreateInfoEXT(const PipelineRasterizationStateStreamCreateInfoEXT& copy_src);
+    PipelineRasterizationStateStreamCreateInfoEXT& operator=(const PipelineRasterizationStateStreamCreateInfoEXT& copy_src);
+    PipelineRasterizationStateStreamCreateInfoEXT();
+    ~PipelineRasterizationStateStreamCreateInfoEXT();
+    void initialize(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineRasterizationStateStreamCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationStateStreamCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this);
+    }
+    VkPipelineRasterizationStateStreamCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT const*>(this);
+    }
+};
+struct CuModuleCreateInfoNVX {
+    VkStructureType sType;
+    const void* pNext{};
+    size_t dataSize;
+    const void* pData{};
+
+    CuModuleCreateInfoNVX(const VkCuModuleCreateInfoNVX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CuModuleCreateInfoNVX(const CuModuleCreateInfoNVX& copy_src);
+    CuModuleCreateInfoNVX& operator=(const CuModuleCreateInfoNVX& copy_src);
+    CuModuleCreateInfoNVX();
+    ~CuModuleCreateInfoNVX();
+    void initialize(const VkCuModuleCreateInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CuModuleCreateInfoNVX* copy_src, PNextCopyState* copy_state = {});
+    VkCuModuleCreateInfoNVX* ptr() { return reinterpret_cast<VkCuModuleCreateInfoNVX*>(this); }
+    VkCuModuleCreateInfoNVX const* ptr() const { return reinterpret_cast<VkCuModuleCreateInfoNVX const*>(this); }
+};
+struct CuFunctionCreateInfoNVX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCuModuleNVX module;
+    const char* pName{};
+
+    CuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CuFunctionCreateInfoNVX(const CuFunctionCreateInfoNVX& copy_src);
+    CuFunctionCreateInfoNVX& operator=(const CuFunctionCreateInfoNVX& copy_src);
+    CuFunctionCreateInfoNVX();
+    ~CuFunctionCreateInfoNVX();
+    void initialize(const VkCuFunctionCreateInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CuFunctionCreateInfoNVX* copy_src, PNextCopyState* copy_state = {});
+    VkCuFunctionCreateInfoNVX* ptr() { return reinterpret_cast<VkCuFunctionCreateInfoNVX*>(this); }
+    VkCuFunctionCreateInfoNVX const* ptr() const { return reinterpret_cast<VkCuFunctionCreateInfoNVX const*>(this); }
+};
+struct CuLaunchInfoNVX {
+    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{};
+
+    CuLaunchInfoNVX(const VkCuLaunchInfoNVX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CuLaunchInfoNVX(const CuLaunchInfoNVX& copy_src);
+    CuLaunchInfoNVX& operator=(const CuLaunchInfoNVX& copy_src);
+    CuLaunchInfoNVX();
+    ~CuLaunchInfoNVX();
+    void initialize(const VkCuLaunchInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CuLaunchInfoNVX* copy_src, PNextCopyState* copy_state = {});
+    VkCuLaunchInfoNVX* ptr() { return reinterpret_cast<VkCuLaunchInfoNVX*>(this); }
+    VkCuLaunchInfoNVX const* ptr() const { return reinterpret_cast<VkCuLaunchInfoNVX const*>(this); }
+};
+struct ImageViewHandleInfoNVX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+    VkDescriptorType descriptorType;
+    VkSampler sampler;
+
+    ImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageViewHandleInfoNVX(const ImageViewHandleInfoNVX& copy_src);
+    ImageViewHandleInfoNVX& operator=(const ImageViewHandleInfoNVX& copy_src);
+    ImageViewHandleInfoNVX();
+    ~ImageViewHandleInfoNVX();
+    void initialize(const VkImageViewHandleInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageViewHandleInfoNVX* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewHandleInfoNVX* ptr() { return reinterpret_cast<VkImageViewHandleInfoNVX*>(this); }
+    VkImageViewHandleInfoNVX const* ptr() const { return reinterpret_cast<VkImageViewHandleInfoNVX const*>(this); }
+};
+struct ImageViewAddressPropertiesNVX {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceAddress deviceAddress;
+    VkDeviceSize size;
+
+    ImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    ImageViewAddressPropertiesNVX(const ImageViewAddressPropertiesNVX& copy_src);
+    ImageViewAddressPropertiesNVX& operator=(const ImageViewAddressPropertiesNVX& copy_src);
+    ImageViewAddressPropertiesNVX();
+    ~ImageViewAddressPropertiesNVX();
+    void initialize(const VkImageViewAddressPropertiesNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageViewAddressPropertiesNVX* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewAddressPropertiesNVX* ptr() { return reinterpret_cast<VkImageViewAddressPropertiesNVX*>(this); }
+    VkImageViewAddressPropertiesNVX const* ptr() const { return reinterpret_cast<VkImageViewAddressPropertiesNVX const*>(this); }
+};
+struct TextureLODGatherFormatPropertiesAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 supportsTextureGatherLODBiasAMD;
+
+    TextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    TextureLODGatherFormatPropertiesAMD(const TextureLODGatherFormatPropertiesAMD& copy_src);
+    TextureLODGatherFormatPropertiesAMD& operator=(const TextureLODGatherFormatPropertiesAMD& copy_src);
+    TextureLODGatherFormatPropertiesAMD();
+    ~TextureLODGatherFormatPropertiesAMD();
+    void initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const TextureLODGatherFormatPropertiesAMD* 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 StreamDescriptorSurfaceCreateInfoGGP {
+    VkStructureType sType;
+    const void* pNext{};
+    VkStreamDescriptorSurfaceCreateFlagsGGP flags;
+    GgpStreamDescriptor streamDescriptor;
+
+    StreamDescriptorSurfaceCreateInfoGGP(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    StreamDescriptorSurfaceCreateInfoGGP(const StreamDescriptorSurfaceCreateInfoGGP& copy_src);
+    StreamDescriptorSurfaceCreateInfoGGP& operator=(const StreamDescriptorSurfaceCreateInfoGGP& copy_src);
+    StreamDescriptorSurfaceCreateInfoGGP();
+    ~StreamDescriptorSurfaceCreateInfoGGP();
+    void initialize(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const StreamDescriptorSurfaceCreateInfoGGP* 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 PhysicalDeviceCornerSampledImageFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cornerSampledImage;
+
+    PhysicalDeviceCornerSampledImageFeaturesNV(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCornerSampledImageFeaturesNV(const PhysicalDeviceCornerSampledImageFeaturesNV& copy_src);
+    PhysicalDeviceCornerSampledImageFeaturesNV& operator=(const PhysicalDeviceCornerSampledImageFeaturesNV& copy_src);
+    PhysicalDeviceCornerSampledImageFeaturesNV();
+    ~PhysicalDeviceCornerSampledImageFeaturesNV();
+    void initialize(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCornerSampledImageFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCornerSampledImageFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCornerSampledImageFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV const*>(this);
+    }
+};
+struct ExternalMemoryImageCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagsNV handleTypes;
+
+    ExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    ExternalMemoryImageCreateInfoNV(const ExternalMemoryImageCreateInfoNV& copy_src);
+    ExternalMemoryImageCreateInfoNV& operator=(const ExternalMemoryImageCreateInfoNV& copy_src);
+    ExternalMemoryImageCreateInfoNV();
+    ~ExternalMemoryImageCreateInfoNV();
+    void initialize(const VkExternalMemoryImageCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExternalMemoryImageCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkExternalMemoryImageCreateInfoNV* ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this); }
+    VkExternalMemoryImageCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkExternalMemoryImageCreateInfoNV const*>(this);
+    }
+};
+struct ExportMemoryAllocateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagsNV handleTypes;
+
+    ExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    ExportMemoryAllocateInfoNV(const ExportMemoryAllocateInfoNV& copy_src);
+    ExportMemoryAllocateInfoNV& operator=(const ExportMemoryAllocateInfoNV& copy_src);
+    ExportMemoryAllocateInfoNV();
+    ~ExportMemoryAllocateInfoNV();
+    void initialize(const VkExportMemoryAllocateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMemoryAllocateInfoNV* 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 ImportMemoryWin32HandleInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagsNV handleType;
+    HANDLE handle;
+
+    ImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    ImportMemoryWin32HandleInfoNV(const ImportMemoryWin32HandleInfoNV& copy_src);
+    ImportMemoryWin32HandleInfoNV& operator=(const ImportMemoryWin32HandleInfoNV& copy_src);
+    ImportMemoryWin32HandleInfoNV();
+    ~ImportMemoryWin32HandleInfoNV();
+    void initialize(const VkImportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportMemoryWin32HandleInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryWin32HandleInfoNV* ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this); }
+    VkImportMemoryWin32HandleInfoNV const* ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV const*>(this); }
+};
+struct ExportMemoryWin32HandleInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    const SECURITY_ATTRIBUTES* pAttributes{};
+    DWORD dwAccess;
+
+    ExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    ExportMemoryWin32HandleInfoNV(const ExportMemoryWin32HandleInfoNV& copy_src);
+    ExportMemoryWin32HandleInfoNV& operator=(const ExportMemoryWin32HandleInfoNV& copy_src);
+    ExportMemoryWin32HandleInfoNV();
+    ~ExportMemoryWin32HandleInfoNV();
+    void initialize(const VkExportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMemoryWin32HandleInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkExportMemoryWin32HandleInfoNV* ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this); }
+    VkExportMemoryWin32HandleInfoNV const* ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV const*>(this); }
+};
+struct Win32KeyedMutexAcquireReleaseInfoNV {
+    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{};
+
+    Win32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    Win32KeyedMutexAcquireReleaseInfoNV(const Win32KeyedMutexAcquireReleaseInfoNV& copy_src);
+    Win32KeyedMutexAcquireReleaseInfoNV& operator=(const Win32KeyedMutexAcquireReleaseInfoNV& copy_src);
+    Win32KeyedMutexAcquireReleaseInfoNV();
+    ~Win32KeyedMutexAcquireReleaseInfoNV();
+    void initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const Win32KeyedMutexAcquireReleaseInfoNV* 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 ValidationFlagsEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t disabledValidationCheckCount;
+    const VkValidationCheckEXT* pDisabledValidationChecks{};
+
+    ValidationFlagsEXT(const VkValidationFlagsEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ValidationFlagsEXT(const ValidationFlagsEXT& copy_src);
+    ValidationFlagsEXT& operator=(const ValidationFlagsEXT& copy_src);
+    ValidationFlagsEXT();
+    ~ValidationFlagsEXT();
+    void initialize(const VkValidationFlagsEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ValidationFlagsEXT* 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 ViSurfaceCreateInfoNN {
+    VkStructureType sType;
+    const void* pNext{};
+    VkViSurfaceCreateFlagsNN flags;
+    void* window{};
+
+    ViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ViSurfaceCreateInfoNN(const ViSurfaceCreateInfoNN& copy_src);
+    ViSurfaceCreateInfoNN& operator=(const ViSurfaceCreateInfoNN& copy_src);
+    ViSurfaceCreateInfoNN();
+    ~ViSurfaceCreateInfoNN();
+    void initialize(const VkViSurfaceCreateInfoNN* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ViSurfaceCreateInfoNN* 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 ImageViewASTCDecodeModeEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat decodeMode;
+
+    ImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    ImageViewASTCDecodeModeEXT(const ImageViewASTCDecodeModeEXT& copy_src);
+    ImageViewASTCDecodeModeEXT& operator=(const ImageViewASTCDecodeModeEXT& copy_src);
+    ImageViewASTCDecodeModeEXT();
+    ~ImageViewASTCDecodeModeEXT();
+    void initialize(const VkImageViewASTCDecodeModeEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageViewASTCDecodeModeEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewASTCDecodeModeEXT* ptr() { return reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this); }
+    VkImageViewASTCDecodeModeEXT const* ptr() const { return reinterpret_cast<VkImageViewASTCDecodeModeEXT const*>(this); }
+};
+struct PhysicalDeviceASTCDecodeFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 decodeModeSharedExponent;
+
+    PhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    PhysicalDeviceASTCDecodeFeaturesEXT(const PhysicalDeviceASTCDecodeFeaturesEXT& copy_src);
+    PhysicalDeviceASTCDecodeFeaturesEXT& operator=(const PhysicalDeviceASTCDecodeFeaturesEXT& copy_src);
+    PhysicalDeviceASTCDecodeFeaturesEXT();
+    ~PhysicalDeviceASTCDecodeFeaturesEXT();
+    void initialize(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceASTCDecodeFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceASTCDecodeFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this); }
+    VkPhysicalDeviceASTCDecodeFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDevicePipelineRobustnessFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineRobustness;
+
+    PhysicalDevicePipelineRobustnessFeaturesEXT(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePipelineRobustnessFeaturesEXT(const PhysicalDevicePipelineRobustnessFeaturesEXT& copy_src);
+    PhysicalDevicePipelineRobustnessFeaturesEXT& operator=(const PhysicalDevicePipelineRobustnessFeaturesEXT& copy_src);
+    PhysicalDevicePipelineRobustnessFeaturesEXT();
+    ~PhysicalDevicePipelineRobustnessFeaturesEXT();
+    void initialize(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePipelineRobustnessFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDevicePipelineRobustnessPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers;
+    VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers;
+    VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs;
+    VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages;
+
+    PhysicalDevicePipelineRobustnessPropertiesEXT(const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePipelineRobustnessPropertiesEXT(const PhysicalDevicePipelineRobustnessPropertiesEXT& copy_src);
+    PhysicalDevicePipelineRobustnessPropertiesEXT& operator=(const PhysicalDevicePipelineRobustnessPropertiesEXT& copy_src);
+    PhysicalDevicePipelineRobustnessPropertiesEXT();
+    ~PhysicalDevicePipelineRobustnessPropertiesEXT();
+    void initialize(const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePipelineRobustnessPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(this);
+    }
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT const*>(this);
+    }
+};
+struct PipelineRobustnessCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineRobustnessBufferBehaviorEXT storageBuffers;
+    VkPipelineRobustnessBufferBehaviorEXT uniformBuffers;
+    VkPipelineRobustnessBufferBehaviorEXT vertexInputs;
+    VkPipelineRobustnessImageBehaviorEXT images;
+
+    PipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    PipelineRobustnessCreateInfoEXT(const PipelineRobustnessCreateInfoEXT& copy_src);
+    PipelineRobustnessCreateInfoEXT& operator=(const PipelineRobustnessCreateInfoEXT& copy_src);
+    PipelineRobustnessCreateInfoEXT();
+    ~PipelineRobustnessCreateInfoEXT();
+    void initialize(const VkPipelineRobustnessCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineRobustnessCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRobustnessCreateInfoEXT* ptr() { return reinterpret_cast<VkPipelineRobustnessCreateInfoEXT*>(this); }
+    VkPipelineRobustnessCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineRobustnessCreateInfoEXT const*>(this);
+    }
+};
+struct ConditionalRenderingBeginInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer buffer;
+    VkDeviceSize offset;
+    VkConditionalRenderingFlagsEXT flags;
+
+    ConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    ConditionalRenderingBeginInfoEXT(const ConditionalRenderingBeginInfoEXT& copy_src);
+    ConditionalRenderingBeginInfoEXT& operator=(const ConditionalRenderingBeginInfoEXT& copy_src);
+    ConditionalRenderingBeginInfoEXT();
+    ~ConditionalRenderingBeginInfoEXT();
+    void initialize(const VkConditionalRenderingBeginInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ConditionalRenderingBeginInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkConditionalRenderingBeginInfoEXT* ptr() { return reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this); }
+    VkConditionalRenderingBeginInfoEXT const* ptr() const {
+        return reinterpret_cast<VkConditionalRenderingBeginInfoEXT const*>(this);
+    }
+};
+struct PhysicalDeviceConditionalRenderingFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 conditionalRendering;
+    VkBool32 inheritedConditionalRendering;
+
+    PhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceConditionalRenderingFeaturesEXT(const PhysicalDeviceConditionalRenderingFeaturesEXT& copy_src);
+    PhysicalDeviceConditionalRenderingFeaturesEXT& operator=(const PhysicalDeviceConditionalRenderingFeaturesEXT& copy_src);
+    PhysicalDeviceConditionalRenderingFeaturesEXT();
+    ~PhysicalDeviceConditionalRenderingFeaturesEXT();
+    void initialize(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceConditionalRenderingFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT const*>(this);
+    }
+};
+struct CommandBufferInheritanceConditionalRenderingInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 conditionalRenderingEnable;
+
+    CommandBufferInheritanceConditionalRenderingInfoEXT(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CommandBufferInheritanceConditionalRenderingInfoEXT(const CommandBufferInheritanceConditionalRenderingInfoEXT& copy_src);
+    CommandBufferInheritanceConditionalRenderingInfoEXT& operator=(
+        const CommandBufferInheritanceConditionalRenderingInfoEXT& copy_src);
+    CommandBufferInheritanceConditionalRenderingInfoEXT();
+    ~CommandBufferInheritanceConditionalRenderingInfoEXT();
+    void initialize(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CommandBufferInheritanceConditionalRenderingInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferInheritanceConditionalRenderingInfoEXT* ptr() {
+        return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this);
+    }
+    VkCommandBufferInheritanceConditionalRenderingInfoEXT const* ptr() const {
+        return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT const*>(this);
+    }
+};
+struct PipelineViewportWScalingStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 viewportWScalingEnable;
+    uint32_t viewportCount;
+    const VkViewportWScalingNV* pViewportWScalings{};
+
+    PipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineViewportWScalingStateCreateInfoNV(const PipelineViewportWScalingStateCreateInfoNV& copy_src);
+    PipelineViewportWScalingStateCreateInfoNV& operator=(const PipelineViewportWScalingStateCreateInfoNV& copy_src);
+    PipelineViewportWScalingStateCreateInfoNV();
+    ~PipelineViewportWScalingStateCreateInfoNV();
+    void initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineViewportWScalingStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportWScalingStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this);
+    }
+    VkPipelineViewportWScalingStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV const*>(this);
+    }
+};
+struct SurfaceCapabilities2EXT {
+    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;
+
+    SurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SurfaceCapabilities2EXT(const SurfaceCapabilities2EXT& copy_src);
+    SurfaceCapabilities2EXT& operator=(const SurfaceCapabilities2EXT& copy_src);
+    SurfaceCapabilities2EXT();
+    ~SurfaceCapabilities2EXT();
+    void initialize(const VkSurfaceCapabilities2EXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SurfaceCapabilities2EXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceCapabilities2EXT* ptr() { return reinterpret_cast<VkSurfaceCapabilities2EXT*>(this); }
+    VkSurfaceCapabilities2EXT const* ptr() const { return reinterpret_cast<VkSurfaceCapabilities2EXT const*>(this); }
+};
+struct DisplayPowerInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDisplayPowerStateEXT powerState;
+
+    DisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DisplayPowerInfoEXT(const DisplayPowerInfoEXT& copy_src);
+    DisplayPowerInfoEXT& operator=(const DisplayPowerInfoEXT& copy_src);
+    DisplayPowerInfoEXT();
+    ~DisplayPowerInfoEXT();
+    void initialize(const VkDisplayPowerInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplayPowerInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayPowerInfoEXT* ptr() { return reinterpret_cast<VkDisplayPowerInfoEXT*>(this); }
+    VkDisplayPowerInfoEXT const* ptr() const { return reinterpret_cast<VkDisplayPowerInfoEXT const*>(this); }
+};
+struct DeviceEventInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceEventTypeEXT deviceEvent;
+
+    DeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DeviceEventInfoEXT(const DeviceEventInfoEXT& copy_src);
+    DeviceEventInfoEXT& operator=(const DeviceEventInfoEXT& copy_src);
+    DeviceEventInfoEXT();
+    ~DeviceEventInfoEXT();
+    void initialize(const VkDeviceEventInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceEventInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceEventInfoEXT* ptr() { return reinterpret_cast<VkDeviceEventInfoEXT*>(this); }
+    VkDeviceEventInfoEXT const* ptr() const { return reinterpret_cast<VkDeviceEventInfoEXT const*>(this); }
+};
+struct DisplayEventInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDisplayEventTypeEXT displayEvent;
+
+    DisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DisplayEventInfoEXT(const DisplayEventInfoEXT& copy_src);
+    DisplayEventInfoEXT& operator=(const DisplayEventInfoEXT& copy_src);
+    DisplayEventInfoEXT();
+    ~DisplayEventInfoEXT();
+    void initialize(const VkDisplayEventInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplayEventInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayEventInfoEXT* ptr() { return reinterpret_cast<VkDisplayEventInfoEXT*>(this); }
+    VkDisplayEventInfoEXT const* ptr() const { return reinterpret_cast<VkDisplayEventInfoEXT const*>(this); }
+};
+struct SwapchainCounterCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSurfaceCounterFlagsEXT surfaceCounters;
+
+    SwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    SwapchainCounterCreateInfoEXT(const SwapchainCounterCreateInfoEXT& copy_src);
+    SwapchainCounterCreateInfoEXT& operator=(const SwapchainCounterCreateInfoEXT& copy_src);
+    SwapchainCounterCreateInfoEXT();
+    ~SwapchainCounterCreateInfoEXT();
+    void initialize(const VkSwapchainCounterCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SwapchainCounterCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainCounterCreateInfoEXT* ptr() { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this); }
+    VkSwapchainCounterCreateInfoEXT const* ptr() const { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT const*>(this); }
+};
+struct PresentTimesInfoGOOGLE {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    const VkPresentTimeGOOGLE* pTimes{};
+
+    PresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PresentTimesInfoGOOGLE(const PresentTimesInfoGOOGLE& copy_src);
+    PresentTimesInfoGOOGLE& operator=(const PresentTimesInfoGOOGLE& copy_src);
+    PresentTimesInfoGOOGLE();
+    ~PresentTimesInfoGOOGLE();
+    void initialize(const VkPresentTimesInfoGOOGLE* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PresentTimesInfoGOOGLE* copy_src, PNextCopyState* copy_state = {});
+    VkPresentTimesInfoGOOGLE* ptr() { return reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this); }
+    VkPresentTimesInfoGOOGLE const* ptr() const { return reinterpret_cast<VkPresentTimesInfoGOOGLE const*>(this); }
+};
+struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 perViewPositionAllComponents;
+
+    PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src);
+    PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=(
+        const PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src);
+    PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX();
+    ~PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX();
+    void initialize(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
+    }
+    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const*>(this);
+    }
+};
+struct PipelineViewportSwizzleStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineViewportSwizzleStateCreateFlagsNV flags;
+    uint32_t viewportCount;
+    const VkViewportSwizzleNV* pViewportSwizzles{};
+
+    PipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineViewportSwizzleStateCreateInfoNV(const PipelineViewportSwizzleStateCreateInfoNV& copy_src);
+    PipelineViewportSwizzleStateCreateInfoNV& operator=(const PipelineViewportSwizzleStateCreateInfoNV& copy_src);
+    PipelineViewportSwizzleStateCreateInfoNV();
+    ~PipelineViewportSwizzleStateCreateInfoNV();
+    void initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineViewportSwizzleStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportSwizzleStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
+    }
+    VkPipelineViewportSwizzleStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceDiscardRectanglePropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxDiscardRectangles;
+
+    PhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDiscardRectanglePropertiesEXT(const PhysicalDeviceDiscardRectanglePropertiesEXT& copy_src);
+    PhysicalDeviceDiscardRectanglePropertiesEXT& operator=(const PhysicalDeviceDiscardRectanglePropertiesEXT& copy_src);
+    PhysicalDeviceDiscardRectanglePropertiesEXT();
+    ~PhysicalDeviceDiscardRectanglePropertiesEXT();
+    void initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDiscardRectanglePropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT const*>(this);
+    }
+};
+struct PipelineDiscardRectangleStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
+    VkDiscardRectangleModeEXT discardRectangleMode;
+    uint32_t discardRectangleCount;
+    const VkRect2D* pDiscardRectangles{};
+
+    PipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineDiscardRectangleStateCreateInfoEXT(const PipelineDiscardRectangleStateCreateInfoEXT& copy_src);
+    PipelineDiscardRectangleStateCreateInfoEXT& operator=(const PipelineDiscardRectangleStateCreateInfoEXT& copy_src);
+    PipelineDiscardRectangleStateCreateInfoEXT();
+    ~PipelineDiscardRectangleStateCreateInfoEXT();
+    void initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineDiscardRectangleStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineDiscardRectangleStateCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
+    }
+    VkPipelineDiscardRectangleStateCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT const*>(this);
+    }
+};
+struct PhysicalDeviceConservativeRasterizationPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    float primitiveOverestimationSize;
+    float maxExtraPrimitiveOverestimationSize;
+    float extraPrimitiveOverestimationSizeGranularity;
+    VkBool32 primitiveUnderestimation;
+    VkBool32 conservativePointAndLineRasterization;
+    VkBool32 degenerateTrianglesRasterized;
+    VkBool32 degenerateLinesRasterized;
+    VkBool32 fullyCoveredFragmentShaderInputVariable;
+    VkBool32 conservativeRasterizationPostDepthCoverage;
+
+    PhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceConservativeRasterizationPropertiesEXT(const PhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src);
+    PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=(
+        const PhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src);
+    PhysicalDeviceConservativeRasterizationPropertiesEXT();
+    ~PhysicalDeviceConservativeRasterizationPropertiesEXT();
+    void initialize(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceConservativeRasterizationPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT const*>(this);
+    }
+};
+struct PipelineRasterizationConservativeStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
+    VkConservativeRasterizationModeEXT conservativeRasterizationMode;
+    float extraPrimitiveOverestimationSize;
+
+    PipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineRasterizationConservativeStateCreateInfoEXT(const PipelineRasterizationConservativeStateCreateInfoEXT& copy_src);
+    PipelineRasterizationConservativeStateCreateInfoEXT& operator=(
+        const PipelineRasterizationConservativeStateCreateInfoEXT& copy_src);
+    PipelineRasterizationConservativeStateCreateInfoEXT();
+    ~PipelineRasterizationConservativeStateCreateInfoEXT();
+    void initialize(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineRasterizationConservativeStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationConservativeStateCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
+    }
+    VkPipelineRasterizationConservativeStateCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT const*>(this);
+    }
+};
+struct PhysicalDeviceDepthClipEnableFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 depthClipEnable;
+
+    PhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDepthClipEnableFeaturesEXT(const PhysicalDeviceDepthClipEnableFeaturesEXT& copy_src);
+    PhysicalDeviceDepthClipEnableFeaturesEXT& operator=(const PhysicalDeviceDepthClipEnableFeaturesEXT& copy_src);
+    PhysicalDeviceDepthClipEnableFeaturesEXT();
+    ~PhysicalDeviceDepthClipEnableFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDepthClipEnableFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthClipEnableFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDepthClipEnableFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT const*>(this);
+    }
+};
+struct PipelineRasterizationDepthClipStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
+    VkBool32 depthClipEnable;
+
+    PipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineRasterizationDepthClipStateCreateInfoEXT(const PipelineRasterizationDepthClipStateCreateInfoEXT& copy_src);
+    PipelineRasterizationDepthClipStateCreateInfoEXT& operator=(const PipelineRasterizationDepthClipStateCreateInfoEXT& copy_src);
+    PipelineRasterizationDepthClipStateCreateInfoEXT();
+    ~PipelineRasterizationDepthClipStateCreateInfoEXT();
+    void initialize(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineRasterizationDepthClipStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(this);
+    }
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT const*>(this);
+    }
+};
+struct HdrMetadataEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkXYColorEXT displayPrimaryRed;
+    VkXYColorEXT displayPrimaryGreen;
+    VkXYColorEXT displayPrimaryBlue;
+    VkXYColorEXT whitePoint;
+    float maxLuminance;
+    float minLuminance;
+    float maxContentLightLevel;
+    float maxFrameAverageLightLevel;
+
+    HdrMetadataEXT(const VkHdrMetadataEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    HdrMetadataEXT(const HdrMetadataEXT& copy_src);
+    HdrMetadataEXT& operator=(const HdrMetadataEXT& copy_src);
+    HdrMetadataEXT();
+    ~HdrMetadataEXT();
+    void initialize(const VkHdrMetadataEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const HdrMetadataEXT* copy_src, PNextCopyState* copy_state = {});
+    VkHdrMetadataEXT* ptr() { return reinterpret_cast<VkHdrMetadataEXT*>(this); }
+    VkHdrMetadataEXT const* ptr() const { return reinterpret_cast<VkHdrMetadataEXT const*>(this); }
+};
+struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 relaxedLineRasterization;
+
+    PhysicalDeviceRelaxedLineRasterizationFeaturesIMG(const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRelaxedLineRasterizationFeaturesIMG(const PhysicalDeviceRelaxedLineRasterizationFeaturesIMG& copy_src);
+    PhysicalDeviceRelaxedLineRasterizationFeaturesIMG& operator=(const PhysicalDeviceRelaxedLineRasterizationFeaturesIMG& copy_src);
+    PhysicalDeviceRelaxedLineRasterizationFeaturesIMG();
+    ~PhysicalDeviceRelaxedLineRasterizationFeaturesIMG();
+    void initialize(const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRelaxedLineRasterizationFeaturesIMG* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(this);
+    }
+    VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const*>(this);
+    }
+};
+struct DebugUtilsLabelEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    const char* pLabelName{};
+    float color[4];
+
+    DebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DebugUtilsLabelEXT(const DebugUtilsLabelEXT& copy_src);
+    DebugUtilsLabelEXT& operator=(const DebugUtilsLabelEXT& copy_src);
+    DebugUtilsLabelEXT();
+    ~DebugUtilsLabelEXT();
+    void initialize(const VkDebugUtilsLabelEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DebugUtilsLabelEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugUtilsLabelEXT* ptr() { return reinterpret_cast<VkDebugUtilsLabelEXT*>(this); }
+    VkDebugUtilsLabelEXT const* ptr() const { return reinterpret_cast<VkDebugUtilsLabelEXT const*>(this); }
+};
+struct DebugUtilsObjectNameInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkObjectType objectType;
+    uint64_t objectHandle;
+    const char* pObjectName{};
+
+    DebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    DebugUtilsObjectNameInfoEXT(const DebugUtilsObjectNameInfoEXT& copy_src);
+    DebugUtilsObjectNameInfoEXT& operator=(const DebugUtilsObjectNameInfoEXT& copy_src);
+    DebugUtilsObjectNameInfoEXT();
+    ~DebugUtilsObjectNameInfoEXT();
+    void initialize(const VkDebugUtilsObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DebugUtilsObjectNameInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugUtilsObjectNameInfoEXT* ptr() { return reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this); }
+    VkDebugUtilsObjectNameInfoEXT const* ptr() const { return reinterpret_cast<VkDebugUtilsObjectNameInfoEXT const*>(this); }
+};
+struct DebugUtilsMessengerCallbackDataEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
+    const char* pMessageIdName{};
+    int32_t messageIdNumber;
+    const char* pMessage{};
+    uint32_t queueLabelCount;
+    DebugUtilsLabelEXT* pQueueLabels{};
+    uint32_t cmdBufLabelCount;
+    DebugUtilsLabelEXT* pCmdBufLabels{};
+    uint32_t objectCount;
+    DebugUtilsObjectNameInfoEXT* pObjects{};
+
+    DebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    DebugUtilsMessengerCallbackDataEXT(const DebugUtilsMessengerCallbackDataEXT& copy_src);
+    DebugUtilsMessengerCallbackDataEXT& operator=(const DebugUtilsMessengerCallbackDataEXT& copy_src);
+    DebugUtilsMessengerCallbackDataEXT();
+    ~DebugUtilsMessengerCallbackDataEXT();
+    void initialize(const VkDebugUtilsMessengerCallbackDataEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DebugUtilsMessengerCallbackDataEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugUtilsMessengerCallbackDataEXT* ptr() { return reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this); }
+    VkDebugUtilsMessengerCallbackDataEXT const* ptr() const {
+        return reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT const*>(this);
+    }
+};
+struct DebugUtilsMessengerCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDebugUtilsMessengerCreateFlagsEXT flags;
+    VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
+    VkDebugUtilsMessageTypeFlagsEXT messageType;
+    PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
+    void* pUserData{};
+
+    DebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    DebugUtilsMessengerCreateInfoEXT(const DebugUtilsMessengerCreateInfoEXT& copy_src);
+    DebugUtilsMessengerCreateInfoEXT& operator=(const DebugUtilsMessengerCreateInfoEXT& copy_src);
+    DebugUtilsMessengerCreateInfoEXT();
+    ~DebugUtilsMessengerCreateInfoEXT();
+    void initialize(const VkDebugUtilsMessengerCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DebugUtilsMessengerCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugUtilsMessengerCreateInfoEXT* ptr() { return reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this); }
+    VkDebugUtilsMessengerCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT const*>(this);
+    }
+};
+struct DebugUtilsObjectTagInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkObjectType objectType;
+    uint64_t objectHandle;
+    uint64_t tagName;
+    size_t tagSize;
+    const void* pTag{};
+
+    DebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    DebugUtilsObjectTagInfoEXT(const DebugUtilsObjectTagInfoEXT& copy_src);
+    DebugUtilsObjectTagInfoEXT& operator=(const DebugUtilsObjectTagInfoEXT& copy_src);
+    DebugUtilsObjectTagInfoEXT();
+    ~DebugUtilsObjectTagInfoEXT();
+    void initialize(const VkDebugUtilsObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DebugUtilsObjectTagInfoEXT* 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 AndroidHardwareBufferUsageANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t androidHardwareBufferUsage;
+
+    AndroidHardwareBufferUsageANDROID(const VkAndroidHardwareBufferUsageANDROID* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    AndroidHardwareBufferUsageANDROID(const AndroidHardwareBufferUsageANDROID& copy_src);
+    AndroidHardwareBufferUsageANDROID& operator=(const AndroidHardwareBufferUsageANDROID& copy_src);
+    AndroidHardwareBufferUsageANDROID();
+    ~AndroidHardwareBufferUsageANDROID();
+    void initialize(const VkAndroidHardwareBufferUsageANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AndroidHardwareBufferUsageANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkAndroidHardwareBufferUsageANDROID* ptr() { return reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(this); }
+    VkAndroidHardwareBufferUsageANDROID const* ptr() const {
+        return reinterpret_cast<VkAndroidHardwareBufferUsageANDROID const*>(this);
+    }
+};
+struct AndroidHardwareBufferPropertiesANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize allocationSize;
+    uint32_t memoryTypeBits;
+
+    AndroidHardwareBufferPropertiesANDROID(const VkAndroidHardwareBufferPropertiesANDROID* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AndroidHardwareBufferPropertiesANDROID(const AndroidHardwareBufferPropertiesANDROID& copy_src);
+    AndroidHardwareBufferPropertiesANDROID& operator=(const AndroidHardwareBufferPropertiesANDROID& copy_src);
+    AndroidHardwareBufferPropertiesANDROID();
+    ~AndroidHardwareBufferPropertiesANDROID();
+    void initialize(const VkAndroidHardwareBufferPropertiesANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AndroidHardwareBufferPropertiesANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkAndroidHardwareBufferPropertiesANDROID* ptr() { return reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(this); }
+    VkAndroidHardwareBufferPropertiesANDROID const* ptr() const {
+        return reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID const*>(this);
+    }
+};
+struct AndroidHardwareBufferFormatPropertiesANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat format;
+    uint64_t externalFormat;
+    VkFormatFeatureFlags formatFeatures;
+    VkComponentMapping samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion suggestedYcbcrModel;
+    VkSamplerYcbcrRange suggestedYcbcrRange;
+    VkChromaLocation suggestedXChromaOffset;
+    VkChromaLocation suggestedYChromaOffset;
+
+    AndroidHardwareBufferFormatPropertiesANDROID(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AndroidHardwareBufferFormatPropertiesANDROID(const AndroidHardwareBufferFormatPropertiesANDROID& copy_src);
+    AndroidHardwareBufferFormatPropertiesANDROID& operator=(const AndroidHardwareBufferFormatPropertiesANDROID& copy_src);
+    AndroidHardwareBufferFormatPropertiesANDROID();
+    ~AndroidHardwareBufferFormatPropertiesANDROID();
+    void initialize(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AndroidHardwareBufferFormatPropertiesANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkAndroidHardwareBufferFormatPropertiesANDROID* ptr() {
+        return reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this);
+    }
+    VkAndroidHardwareBufferFormatPropertiesANDROID const* ptr() const {
+        return reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID const*>(this);
+    }
+};
+struct ImportAndroidHardwareBufferInfoANDROID {
+    VkStructureType sType;
+    const void* pNext{};
+    struct AHardwareBuffer* buffer{};
+
+    ImportAndroidHardwareBufferInfoANDROID(const VkImportAndroidHardwareBufferInfoANDROID* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImportAndroidHardwareBufferInfoANDROID(const ImportAndroidHardwareBufferInfoANDROID& copy_src);
+    ImportAndroidHardwareBufferInfoANDROID& operator=(const ImportAndroidHardwareBufferInfoANDROID& copy_src);
+    ImportAndroidHardwareBufferInfoANDROID();
+    ~ImportAndroidHardwareBufferInfoANDROID();
+    void initialize(const VkImportAndroidHardwareBufferInfoANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportAndroidHardwareBufferInfoANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkImportAndroidHardwareBufferInfoANDROID* ptr() { return reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this); }
+    VkImportAndroidHardwareBufferInfoANDROID const* ptr() const {
+        return reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID const*>(this);
+    }
+};
+struct MemoryGetAndroidHardwareBufferInfoANDROID {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+
+    MemoryGetAndroidHardwareBufferInfoANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryGetAndroidHardwareBufferInfoANDROID(const MemoryGetAndroidHardwareBufferInfoANDROID& copy_src);
+    MemoryGetAndroidHardwareBufferInfoANDROID& operator=(const MemoryGetAndroidHardwareBufferInfoANDROID& copy_src);
+    MemoryGetAndroidHardwareBufferInfoANDROID();
+    ~MemoryGetAndroidHardwareBufferInfoANDROID();
+    void initialize(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryGetAndroidHardwareBufferInfoANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryGetAndroidHardwareBufferInfoANDROID* ptr() {
+        return reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this);
+    }
+    VkMemoryGetAndroidHardwareBufferInfoANDROID const* ptr() const {
+        return reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID const*>(this);
+    }
+};
+struct ExternalFormatANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t externalFormat;
+
+    ExternalFormatANDROID(const VkExternalFormatANDROID* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ExternalFormatANDROID(const ExternalFormatANDROID& copy_src);
+    ExternalFormatANDROID& operator=(const ExternalFormatANDROID& copy_src);
+    ExternalFormatANDROID();
+    ~ExternalFormatANDROID();
+    void initialize(const VkExternalFormatANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExternalFormatANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkExternalFormatANDROID* ptr() { return reinterpret_cast<VkExternalFormatANDROID*>(this); }
+    VkExternalFormatANDROID const* ptr() const { return reinterpret_cast<VkExternalFormatANDROID const*>(this); }
+};
+struct AndroidHardwareBufferFormatProperties2ANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat format;
+    uint64_t externalFormat;
+    VkFormatFeatureFlags2 formatFeatures;
+    VkComponentMapping samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion suggestedYcbcrModel;
+    VkSamplerYcbcrRange suggestedYcbcrRange;
+    VkChromaLocation suggestedXChromaOffset;
+    VkChromaLocation suggestedYChromaOffset;
+
+    AndroidHardwareBufferFormatProperties2ANDROID(const VkAndroidHardwareBufferFormatProperties2ANDROID* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AndroidHardwareBufferFormatProperties2ANDROID(const AndroidHardwareBufferFormatProperties2ANDROID& copy_src);
+    AndroidHardwareBufferFormatProperties2ANDROID& operator=(const AndroidHardwareBufferFormatProperties2ANDROID& copy_src);
+    AndroidHardwareBufferFormatProperties2ANDROID();
+    ~AndroidHardwareBufferFormatProperties2ANDROID();
+    void initialize(const VkAndroidHardwareBufferFormatProperties2ANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AndroidHardwareBufferFormatProperties2ANDROID* 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 PhysicalDeviceShaderEnqueueFeaturesAMDX {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderEnqueue;
+
+    PhysicalDeviceShaderEnqueueFeaturesAMDX(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderEnqueueFeaturesAMDX(const PhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src);
+    PhysicalDeviceShaderEnqueueFeaturesAMDX& operator=(const PhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src);
+    PhysicalDeviceShaderEnqueueFeaturesAMDX();
+    ~PhysicalDeviceShaderEnqueueFeaturesAMDX();
+    void initialize(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderEnqueueFeaturesAMDX* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderEnqueueFeaturesAMDX* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(this); }
+    VkPhysicalDeviceShaderEnqueueFeaturesAMDX const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderEnqueueFeaturesAMDX const*>(this);
+    }
+};
+struct PhysicalDeviceShaderEnqueuePropertiesAMDX {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxExecutionGraphDepth;
+    uint32_t maxExecutionGraphShaderOutputNodes;
+    uint32_t maxExecutionGraphShaderPayloadSize;
+    uint32_t maxExecutionGraphShaderPayloadCount;
+    uint32_t executionGraphDispatchAddressAlignment;
+
+    PhysicalDeviceShaderEnqueuePropertiesAMDX(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderEnqueuePropertiesAMDX(const PhysicalDeviceShaderEnqueuePropertiesAMDX& copy_src);
+    PhysicalDeviceShaderEnqueuePropertiesAMDX& operator=(const PhysicalDeviceShaderEnqueuePropertiesAMDX& copy_src);
+    PhysicalDeviceShaderEnqueuePropertiesAMDX();
+    ~PhysicalDeviceShaderEnqueuePropertiesAMDX();
+    void initialize(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderEnqueuePropertiesAMDX* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderEnqueuePropertiesAMDX* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderEnqueuePropertiesAMDX*>(this);
+    }
+    VkPhysicalDeviceShaderEnqueuePropertiesAMDX const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderEnqueuePropertiesAMDX const*>(this);
+    }
+};
+struct ExecutionGraphPipelineScratchSizeAMDX {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize size;
+
+    ExecutionGraphPipelineScratchSizeAMDX(const VkExecutionGraphPipelineScratchSizeAMDX* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    ExecutionGraphPipelineScratchSizeAMDX(const ExecutionGraphPipelineScratchSizeAMDX& copy_src);
+    ExecutionGraphPipelineScratchSizeAMDX& operator=(const ExecutionGraphPipelineScratchSizeAMDX& copy_src);
+    ExecutionGraphPipelineScratchSizeAMDX();
+    ~ExecutionGraphPipelineScratchSizeAMDX();
+    void initialize(const VkExecutionGraphPipelineScratchSizeAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExecutionGraphPipelineScratchSizeAMDX* copy_src, PNextCopyState* copy_state = {});
+    VkExecutionGraphPipelineScratchSizeAMDX* ptr() { return reinterpret_cast<VkExecutionGraphPipelineScratchSizeAMDX*>(this); }
+    VkExecutionGraphPipelineScratchSizeAMDX const* ptr() const {
+        return reinterpret_cast<VkExecutionGraphPipelineScratchSizeAMDX const*>(this);
+    }
+};
+struct ExecutionGraphPipelineCreateInfoAMDX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags flags;
+    uint32_t stageCount;
+    PipelineShaderStageCreateInfo* pStages{};
+    PipelineLibraryCreateInfoKHR* pLibraryInfo{};
+    VkPipelineLayout layout;
+    VkPipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+
+    ExecutionGraphPipelineCreateInfoAMDX(const VkExecutionGraphPipelineCreateInfoAMDX* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    ExecutionGraphPipelineCreateInfoAMDX(const ExecutionGraphPipelineCreateInfoAMDX& copy_src);
+    ExecutionGraphPipelineCreateInfoAMDX& operator=(const ExecutionGraphPipelineCreateInfoAMDX& copy_src);
+    ExecutionGraphPipelineCreateInfoAMDX();
+    ~ExecutionGraphPipelineCreateInfoAMDX();
+    void initialize(const VkExecutionGraphPipelineCreateInfoAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExecutionGraphPipelineCreateInfoAMDX* copy_src, PNextCopyState* copy_state = {});
+    VkExecutionGraphPipelineCreateInfoAMDX* ptr() { return reinterpret_cast<VkExecutionGraphPipelineCreateInfoAMDX*>(this); }
+    VkExecutionGraphPipelineCreateInfoAMDX const* ptr() const {
+        return reinterpret_cast<VkExecutionGraphPipelineCreateInfoAMDX const*>(this);
+    }
+};
+union DeviceOrHostAddressConstAMDX {
+    VkDeviceAddress deviceAddress;
+    const void* hostAddress{};
+
+    DeviceOrHostAddressConstAMDX(const VkDeviceOrHostAddressConstAMDX* in_struct, PNextCopyState* copy_state = {});
+    DeviceOrHostAddressConstAMDX(const DeviceOrHostAddressConstAMDX& copy_src);
+    DeviceOrHostAddressConstAMDX& operator=(const DeviceOrHostAddressConstAMDX& copy_src);
+    DeviceOrHostAddressConstAMDX();
+    ~DeviceOrHostAddressConstAMDX();
+    void initialize(const VkDeviceOrHostAddressConstAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceOrHostAddressConstAMDX* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceOrHostAddressConstAMDX* ptr() { return reinterpret_cast<VkDeviceOrHostAddressConstAMDX*>(this); }
+    VkDeviceOrHostAddressConstAMDX const* ptr() const { return reinterpret_cast<VkDeviceOrHostAddressConstAMDX const*>(this); }
+};
+struct PipelineShaderStageNodeCreateInfoAMDX {
+    VkStructureType sType;
+    const void* pNext{};
+    const char* pName{};
+    uint32_t index;
+
+    PipelineShaderStageNodeCreateInfoAMDX(const VkPipelineShaderStageNodeCreateInfoAMDX* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PipelineShaderStageNodeCreateInfoAMDX(const PipelineShaderStageNodeCreateInfoAMDX& copy_src);
+    PipelineShaderStageNodeCreateInfoAMDX& operator=(const PipelineShaderStageNodeCreateInfoAMDX& copy_src);
+    PipelineShaderStageNodeCreateInfoAMDX();
+    ~PipelineShaderStageNodeCreateInfoAMDX();
+    void initialize(const VkPipelineShaderStageNodeCreateInfoAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineShaderStageNodeCreateInfoAMDX* 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 SampleLocationsInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSampleCountFlagBits sampleLocationsPerPixel;
+    VkExtent2D sampleLocationGridSize;
+    uint32_t sampleLocationsCount;
+    const VkSampleLocationEXT* pSampleLocations{};
+
+    SampleLocationsInfoEXT(const VkSampleLocationsInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SampleLocationsInfoEXT(const SampleLocationsInfoEXT& copy_src);
+    SampleLocationsInfoEXT& operator=(const SampleLocationsInfoEXT& copy_src);
+    SampleLocationsInfoEXT();
+    ~SampleLocationsInfoEXT();
+    void initialize(const VkSampleLocationsInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SampleLocationsInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSampleLocationsInfoEXT* ptr() { return reinterpret_cast<VkSampleLocationsInfoEXT*>(this); }
+    VkSampleLocationsInfoEXT const* ptr() const { return reinterpret_cast<VkSampleLocationsInfoEXT const*>(this); }
+};
+struct RenderPassSampleLocationsBeginInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t attachmentInitialSampleLocationsCount;
+    const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations{};
+    uint32_t postSubpassSampleLocationsCount;
+    const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations{};
+
+    RenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    RenderPassSampleLocationsBeginInfoEXT(const RenderPassSampleLocationsBeginInfoEXT& copy_src);
+    RenderPassSampleLocationsBeginInfoEXT& operator=(const RenderPassSampleLocationsBeginInfoEXT& copy_src);
+    RenderPassSampleLocationsBeginInfoEXT();
+    ~RenderPassSampleLocationsBeginInfoEXT();
+    void initialize(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassSampleLocationsBeginInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassSampleLocationsBeginInfoEXT* ptr() { return reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this); }
+    VkRenderPassSampleLocationsBeginInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT const*>(this);
+    }
+};
+struct PipelineSampleLocationsStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 sampleLocationsEnable;
+    SampleLocationsInfoEXT sampleLocationsInfo;
+
+    PipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineSampleLocationsStateCreateInfoEXT(const PipelineSampleLocationsStateCreateInfoEXT& copy_src);
+    PipelineSampleLocationsStateCreateInfoEXT& operator=(const PipelineSampleLocationsStateCreateInfoEXT& copy_src);
+    PipelineSampleLocationsStateCreateInfoEXT();
+    ~PipelineSampleLocationsStateCreateInfoEXT();
+    void initialize(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineSampleLocationsStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineSampleLocationsStateCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
+    }
+    VkPipelineSampleLocationsStateCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT const*>(this);
+    }
+};
+struct PhysicalDeviceSampleLocationsPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkSampleCountFlags sampleLocationSampleCounts;
+    VkExtent2D maxSampleLocationGridSize;
+    float sampleLocationCoordinateRange[2];
+    uint32_t sampleLocationSubPixelBits;
+    VkBool32 variableSampleLocations;
+
+    PhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSampleLocationsPropertiesEXT(const PhysicalDeviceSampleLocationsPropertiesEXT& copy_src);
+    PhysicalDeviceSampleLocationsPropertiesEXT& operator=(const PhysicalDeviceSampleLocationsPropertiesEXT& copy_src);
+    PhysicalDeviceSampleLocationsPropertiesEXT();
+    ~PhysicalDeviceSampleLocationsPropertiesEXT();
+    void initialize(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSampleLocationsPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSampleLocationsPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceSampleLocationsPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT const*>(this);
+    }
+};
+struct MultisamplePropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D maxSampleLocationGridSize;
+
+    MultisamplePropertiesEXT(const VkMultisamplePropertiesEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MultisamplePropertiesEXT(const MultisamplePropertiesEXT& copy_src);
+    MultisamplePropertiesEXT& operator=(const MultisamplePropertiesEXT& copy_src);
+    MultisamplePropertiesEXT();
+    ~MultisamplePropertiesEXT();
+    void initialize(const VkMultisamplePropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MultisamplePropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMultisamplePropertiesEXT* ptr() { return reinterpret_cast<VkMultisamplePropertiesEXT*>(this); }
+    VkMultisamplePropertiesEXT const* ptr() const { return reinterpret_cast<VkMultisamplePropertiesEXT const*>(this); }
+};
+struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 advancedBlendCoherentOperations;
+
+    PhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceBlendOperationAdvancedFeaturesEXT(const PhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src);
+    PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=(const PhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src);
+    PhysicalDeviceBlendOperationAdvancedFeaturesEXT();
+    ~PhysicalDeviceBlendOperationAdvancedFeaturesEXT();
+    void initialize(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceBlendOperationAdvancedFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t advancedBlendMaxColorAttachments;
+    VkBool32 advancedBlendIndependentBlend;
+    VkBool32 advancedBlendNonPremultipliedSrcColor;
+    VkBool32 advancedBlendNonPremultipliedDstColor;
+    VkBool32 advancedBlendCorrelatedOverlap;
+    VkBool32 advancedBlendAllOperations;
+
+    PhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceBlendOperationAdvancedPropertiesEXT(const PhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src);
+    PhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=(const PhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src);
+    PhysicalDeviceBlendOperationAdvancedPropertiesEXT();
+    ~PhysicalDeviceBlendOperationAdvancedPropertiesEXT();
+    void initialize(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceBlendOperationAdvancedPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const*>(this);
+    }
+};
+struct PipelineColorBlendAdvancedStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 srcPremultiplied;
+    VkBool32 dstPremultiplied;
+    VkBlendOverlapEXT blendOverlap;
+
+    PipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineColorBlendAdvancedStateCreateInfoEXT(const PipelineColorBlendAdvancedStateCreateInfoEXT& copy_src);
+    PipelineColorBlendAdvancedStateCreateInfoEXT& operator=(const PipelineColorBlendAdvancedStateCreateInfoEXT& copy_src);
+    PipelineColorBlendAdvancedStateCreateInfoEXT();
+    ~PipelineColorBlendAdvancedStateCreateInfoEXT();
+    void initialize(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineColorBlendAdvancedStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineColorBlendAdvancedStateCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
+    }
+    VkPipelineColorBlendAdvancedStateCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT const*>(this);
+    }
+};
+struct PipelineCoverageToColorStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCoverageToColorStateCreateFlagsNV flags;
+    VkBool32 coverageToColorEnable;
+    uint32_t coverageToColorLocation;
+
+    PipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineCoverageToColorStateCreateInfoNV(const PipelineCoverageToColorStateCreateInfoNV& copy_src);
+    PipelineCoverageToColorStateCreateInfoNV& operator=(const PipelineCoverageToColorStateCreateInfoNV& copy_src);
+    PipelineCoverageToColorStateCreateInfoNV();
+    ~PipelineCoverageToColorStateCreateInfoNV();
+    void initialize(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineCoverageToColorStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCoverageToColorStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this);
+    }
+    VkPipelineCoverageToColorStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV const*>(this);
+    }
+};
+struct PipelineCoverageModulationStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCoverageModulationStateCreateFlagsNV flags;
+    VkCoverageModulationModeNV coverageModulationMode;
+    VkBool32 coverageModulationTableEnable;
+    uint32_t coverageModulationTableCount;
+    const float* pCoverageModulationTable{};
+
+    PipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineCoverageModulationStateCreateInfoNV(const PipelineCoverageModulationStateCreateInfoNV& copy_src);
+    PipelineCoverageModulationStateCreateInfoNV& operator=(const PipelineCoverageModulationStateCreateInfoNV& copy_src);
+    PipelineCoverageModulationStateCreateInfoNV();
+    ~PipelineCoverageModulationStateCreateInfoNV();
+    void initialize(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineCoverageModulationStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCoverageModulationStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this);
+    }
+    VkPipelineCoverageModulationStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceShaderSMBuiltinsPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t shaderSMCount;
+    uint32_t shaderWarpsPerSM;
+
+    PhysicalDeviceShaderSMBuiltinsPropertiesNV(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderSMBuiltinsPropertiesNV(const PhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src);
+    PhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=(const PhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src);
+    PhysicalDeviceShaderSMBuiltinsPropertiesNV();
+    ~PhysicalDeviceShaderSMBuiltinsPropertiesNV();
+    void initialize(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderSMBuiltinsPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const*>(this);
+    }
+};
+struct PhysicalDeviceShaderSMBuiltinsFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderSMBuiltins;
+
+    PhysicalDeviceShaderSMBuiltinsFeaturesNV(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderSMBuiltinsFeaturesNV(const PhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src);
+    PhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=(const PhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src);
+    PhysicalDeviceShaderSMBuiltinsFeaturesNV();
+    ~PhysicalDeviceShaderSMBuiltinsFeaturesNV();
+    void initialize(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderSMBuiltinsFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const*>(this);
+    }
+};
+struct DrmFormatModifierPropertiesListEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t drmFormatModifierCount;
+    VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties{};
+
+    DrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    DrmFormatModifierPropertiesListEXT(const DrmFormatModifierPropertiesListEXT& copy_src);
+    DrmFormatModifierPropertiesListEXT& operator=(const DrmFormatModifierPropertiesListEXT& copy_src);
+    DrmFormatModifierPropertiesListEXT();
+    ~DrmFormatModifierPropertiesListEXT();
+    void initialize(const VkDrmFormatModifierPropertiesListEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DrmFormatModifierPropertiesListEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDrmFormatModifierPropertiesListEXT* ptr() { return reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this); }
+    VkDrmFormatModifierPropertiesListEXT const* ptr() const {
+        return reinterpret_cast<VkDrmFormatModifierPropertiesListEXT const*>(this);
+    }
+};
+struct PhysicalDeviceImageDrmFormatModifierInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t drmFormatModifier;
+    VkSharingMode sharingMode;
+    uint32_t queueFamilyIndexCount;
+    const uint32_t* pQueueFamilyIndices{};
+
+    PhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceImageDrmFormatModifierInfoEXT(const PhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src);
+    PhysicalDeviceImageDrmFormatModifierInfoEXT& operator=(const PhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src);
+    PhysicalDeviceImageDrmFormatModifierInfoEXT();
+    ~PhysicalDeviceImageDrmFormatModifierInfoEXT();
+    void initialize(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageDrmFormatModifierInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageDrmFormatModifierInfoEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this);
+    }
+    VkPhysicalDeviceImageDrmFormatModifierInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT const*>(this);
+    }
+};
+struct ImageDrmFormatModifierListCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t drmFormatModifierCount;
+    const uint64_t* pDrmFormatModifiers{};
+
+    ImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageDrmFormatModifierListCreateInfoEXT(const ImageDrmFormatModifierListCreateInfoEXT& copy_src);
+    ImageDrmFormatModifierListCreateInfoEXT& operator=(const ImageDrmFormatModifierListCreateInfoEXT& copy_src);
+    ImageDrmFormatModifierListCreateInfoEXT();
+    ~ImageDrmFormatModifierListCreateInfoEXT();
+    void initialize(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageDrmFormatModifierListCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageDrmFormatModifierListCreateInfoEXT* ptr() { return reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(this); }
+    VkImageDrmFormatModifierListCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT const*>(this);
+    }
+};
+struct ImageDrmFormatModifierExplicitCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t drmFormatModifier;
+    uint32_t drmFormatModifierPlaneCount;
+    const VkSubresourceLayout* pPlaneLayouts{};
+
+    ImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageDrmFormatModifierExplicitCreateInfoEXT(const ImageDrmFormatModifierExplicitCreateInfoEXT& copy_src);
+    ImageDrmFormatModifierExplicitCreateInfoEXT& operator=(const ImageDrmFormatModifierExplicitCreateInfoEXT& copy_src);
+    ImageDrmFormatModifierExplicitCreateInfoEXT();
+    ~ImageDrmFormatModifierExplicitCreateInfoEXT();
+    void initialize(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageDrmFormatModifierExplicitCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageDrmFormatModifierExplicitCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this);
+    }
+    VkImageDrmFormatModifierExplicitCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT const*>(this);
+    }
+};
+struct ImageDrmFormatModifierPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t drmFormatModifier;
+
+    ImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    ImageDrmFormatModifierPropertiesEXT(const ImageDrmFormatModifierPropertiesEXT& copy_src);
+    ImageDrmFormatModifierPropertiesEXT& operator=(const ImageDrmFormatModifierPropertiesEXT& copy_src);
+    ImageDrmFormatModifierPropertiesEXT();
+    ~ImageDrmFormatModifierPropertiesEXT();
+    void initialize(const VkImageDrmFormatModifierPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageDrmFormatModifierPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageDrmFormatModifierPropertiesEXT* ptr() { return reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>(this); }
+    VkImageDrmFormatModifierPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT const*>(this);
+    }
+};
+struct DrmFormatModifierPropertiesList2EXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t drmFormatModifierCount;
+    VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties{};
+
+    DrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    DrmFormatModifierPropertiesList2EXT(const DrmFormatModifierPropertiesList2EXT& copy_src);
+    DrmFormatModifierPropertiesList2EXT& operator=(const DrmFormatModifierPropertiesList2EXT& copy_src);
+    DrmFormatModifierPropertiesList2EXT();
+    ~DrmFormatModifierPropertiesList2EXT();
+    void initialize(const VkDrmFormatModifierPropertiesList2EXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DrmFormatModifierPropertiesList2EXT* copy_src, PNextCopyState* copy_state = {});
+    VkDrmFormatModifierPropertiesList2EXT* ptr() { return reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(this); }
+    VkDrmFormatModifierPropertiesList2EXT const* ptr() const {
+        return reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT const*>(this);
+    }
+};
+struct ValidationCacheCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkValidationCacheCreateFlagsEXT flags;
+    size_t initialDataSize;
+    const void* pInitialData{};
+
+    ValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    ValidationCacheCreateInfoEXT(const ValidationCacheCreateInfoEXT& copy_src);
+    ValidationCacheCreateInfoEXT& operator=(const ValidationCacheCreateInfoEXT& copy_src);
+    ValidationCacheCreateInfoEXT();
+    ~ValidationCacheCreateInfoEXT();
+    void initialize(const VkValidationCacheCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ValidationCacheCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkValidationCacheCreateInfoEXT* ptr() { return reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this); }
+    VkValidationCacheCreateInfoEXT const* ptr() const { return reinterpret_cast<VkValidationCacheCreateInfoEXT const*>(this); }
+};
+struct ShaderModuleValidationCacheCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkValidationCacheEXT validationCache;
+
+    ShaderModuleValidationCacheCreateInfoEXT(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ShaderModuleValidationCacheCreateInfoEXT(const ShaderModuleValidationCacheCreateInfoEXT& copy_src);
+    ShaderModuleValidationCacheCreateInfoEXT& operator=(const ShaderModuleValidationCacheCreateInfoEXT& copy_src);
+    ShaderModuleValidationCacheCreateInfoEXT();
+    ~ShaderModuleValidationCacheCreateInfoEXT();
+    void initialize(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ShaderModuleValidationCacheCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkShaderModuleValidationCacheCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this);
+    }
+    VkShaderModuleValidationCacheCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT const*>(this);
+    }
+};
+struct ShadingRatePaletteNV {
+    uint32_t shadingRatePaletteEntryCount;
+    const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries{};
+
+    ShadingRatePaletteNV(const VkShadingRatePaletteNV* in_struct, PNextCopyState* copy_state = {});
+    ShadingRatePaletteNV(const ShadingRatePaletteNV& copy_src);
+    ShadingRatePaletteNV& operator=(const ShadingRatePaletteNV& copy_src);
+    ShadingRatePaletteNV();
+    ~ShadingRatePaletteNV();
+    void initialize(const VkShadingRatePaletteNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ShadingRatePaletteNV* copy_src, PNextCopyState* copy_state = {});
+    VkShadingRatePaletteNV* ptr() { return reinterpret_cast<VkShadingRatePaletteNV*>(this); }
+    VkShadingRatePaletteNV const* ptr() const { return reinterpret_cast<VkShadingRatePaletteNV const*>(this); }
+};
+struct PipelineViewportShadingRateImageStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 shadingRateImageEnable;
+    uint32_t viewportCount;
+    ShadingRatePaletteNV* pShadingRatePalettes{};
+
+    PipelineViewportShadingRateImageStateCreateInfoNV(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineViewportShadingRateImageStateCreateInfoNV(const PipelineViewportShadingRateImageStateCreateInfoNV& copy_src);
+    PipelineViewportShadingRateImageStateCreateInfoNV& operator=(const PipelineViewportShadingRateImageStateCreateInfoNV& copy_src);
+    PipelineViewportShadingRateImageStateCreateInfoNV();
+    ~PipelineViewportShadingRateImageStateCreateInfoNV();
+    void initialize(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineViewportShadingRateImageStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportShadingRateImageStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this);
+    }
+    VkPipelineViewportShadingRateImageStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceShadingRateImageFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shadingRateImage;
+    VkBool32 shadingRateCoarseSampleOrder;
+
+    PhysicalDeviceShadingRateImageFeaturesNV(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShadingRateImageFeaturesNV(const PhysicalDeviceShadingRateImageFeaturesNV& copy_src);
+    PhysicalDeviceShadingRateImageFeaturesNV& operator=(const PhysicalDeviceShadingRateImageFeaturesNV& copy_src);
+    PhysicalDeviceShadingRateImageFeaturesNV();
+    ~PhysicalDeviceShadingRateImageFeaturesNV();
+    void initialize(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShadingRateImageFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShadingRateImageFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceShadingRateImageFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceShadingRateImagePropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D shadingRateTexelSize;
+    uint32_t shadingRatePaletteSize;
+    uint32_t shadingRateMaxCoarseSamples;
+
+    PhysicalDeviceShadingRateImagePropertiesNV(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShadingRateImagePropertiesNV(const PhysicalDeviceShadingRateImagePropertiesNV& copy_src);
+    PhysicalDeviceShadingRateImagePropertiesNV& operator=(const PhysicalDeviceShadingRateImagePropertiesNV& copy_src);
+    PhysicalDeviceShadingRateImagePropertiesNV();
+    ~PhysicalDeviceShadingRateImagePropertiesNV();
+    void initialize(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShadingRateImagePropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShadingRateImagePropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this);
+    }
+    VkPhysicalDeviceShadingRateImagePropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV const*>(this);
+    }
+};
+struct CoarseSampleOrderCustomNV {
+    VkShadingRatePaletteEntryNV shadingRate;
+    uint32_t sampleCount;
+    uint32_t sampleLocationCount;
+    const VkCoarseSampleLocationNV* pSampleLocations{};
+
+    CoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV* in_struct, PNextCopyState* copy_state = {});
+    CoarseSampleOrderCustomNV(const CoarseSampleOrderCustomNV& copy_src);
+    CoarseSampleOrderCustomNV& operator=(const CoarseSampleOrderCustomNV& copy_src);
+    CoarseSampleOrderCustomNV();
+    ~CoarseSampleOrderCustomNV();
+    void initialize(const VkCoarseSampleOrderCustomNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CoarseSampleOrderCustomNV* copy_src, PNextCopyState* copy_state = {});
+    VkCoarseSampleOrderCustomNV* ptr() { return reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this); }
+    VkCoarseSampleOrderCustomNV const* ptr() const { return reinterpret_cast<VkCoarseSampleOrderCustomNV const*>(this); }
+};
+struct PipelineViewportCoarseSampleOrderStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCoarseSampleOrderTypeNV sampleOrderType;
+    uint32_t customSampleOrderCount;
+    CoarseSampleOrderCustomNV* pCustomSampleOrders{};
+
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV(const PipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src);
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=(
+        const PipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src);
+    PipelineViewportCoarseSampleOrderStateCreateInfoNV();
+    ~PipelineViewportCoarseSampleOrderStateCreateInfoNV();
+    void initialize(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineViewportCoarseSampleOrderStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this);
+    }
+    VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const*>(this);
+    }
+};
+struct RayTracingShaderGroupCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRayTracingShaderGroupTypeKHR type;
+    uint32_t generalShader;
+    uint32_t closestHitShader;
+    uint32_t anyHitShader;
+    uint32_t intersectionShader;
+
+    RayTracingShaderGroupCreateInfoNV(const VkRayTracingShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    RayTracingShaderGroupCreateInfoNV(const RayTracingShaderGroupCreateInfoNV& copy_src);
+    RayTracingShaderGroupCreateInfoNV& operator=(const RayTracingShaderGroupCreateInfoNV& copy_src);
+    RayTracingShaderGroupCreateInfoNV();
+    ~RayTracingShaderGroupCreateInfoNV();
+    void initialize(const VkRayTracingShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RayTracingShaderGroupCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkRayTracingShaderGroupCreateInfoNV* ptr() { return reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(this); }
+    VkRayTracingShaderGroupCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV const*>(this);
+    }
+};
+struct RayTracingPipelineCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags flags;
+    uint32_t stageCount;
+    PipelineShaderStageCreateInfo* pStages{};
+    uint32_t groupCount;
+    RayTracingShaderGroupCreateInfoNV* pGroups{};
+    uint32_t maxRecursionDepth;
+    VkPipelineLayout layout;
+    VkPipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+
+    RayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    RayTracingPipelineCreateInfoNV(const RayTracingPipelineCreateInfoNV& copy_src);
+    RayTracingPipelineCreateInfoNV& operator=(const RayTracingPipelineCreateInfoNV& copy_src);
+    RayTracingPipelineCreateInfoNV();
+    ~RayTracingPipelineCreateInfoNV();
+    void initialize(const VkRayTracingPipelineCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RayTracingPipelineCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkRayTracingPipelineCreateInfoNV* ptr() { return reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(this); }
+    VkRayTracingPipelineCreateInfoNV const* ptr() const { return reinterpret_cast<VkRayTracingPipelineCreateInfoNV const*>(this); }
+};
+struct GeometryTrianglesNV {
+    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;
+
+    GeometryTrianglesNV(const VkGeometryTrianglesNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    GeometryTrianglesNV(const GeometryTrianglesNV& copy_src);
+    GeometryTrianglesNV& operator=(const GeometryTrianglesNV& copy_src);
+    GeometryTrianglesNV();
+    ~GeometryTrianglesNV();
+    void initialize(const VkGeometryTrianglesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const GeometryTrianglesNV* copy_src, PNextCopyState* copy_state = {});
+    VkGeometryTrianglesNV* ptr() { return reinterpret_cast<VkGeometryTrianglesNV*>(this); }
+    VkGeometryTrianglesNV const* ptr() const { return reinterpret_cast<VkGeometryTrianglesNV const*>(this); }
+};
+struct GeometryAABBNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer aabbData;
+    uint32_t numAABBs;
+    uint32_t stride;
+    VkDeviceSize offset;
+
+    GeometryAABBNV(const VkGeometryAABBNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    GeometryAABBNV(const GeometryAABBNV& copy_src);
+    GeometryAABBNV& operator=(const GeometryAABBNV& copy_src);
+    GeometryAABBNV();
+    ~GeometryAABBNV();
+    void initialize(const VkGeometryAABBNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const GeometryAABBNV* copy_src, PNextCopyState* copy_state = {});
+    VkGeometryAABBNV* ptr() { return reinterpret_cast<VkGeometryAABBNV*>(this); }
+    VkGeometryAABBNV const* ptr() const { return reinterpret_cast<VkGeometryAABBNV const*>(this); }
+};
+struct GeometryNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkGeometryTypeKHR geometryType;
+    VkGeometryDataNV geometry;
+    VkGeometryFlagsKHR flags;
+
+    GeometryNV(const VkGeometryNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    GeometryNV(const GeometryNV& copy_src);
+    GeometryNV& operator=(const GeometryNV& copy_src);
+    GeometryNV();
+    ~GeometryNV();
+    void initialize(const VkGeometryNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const GeometryNV* copy_src, PNextCopyState* copy_state = {});
+    VkGeometryNV* ptr() { return reinterpret_cast<VkGeometryNV*>(this); }
+    VkGeometryNV const* ptr() const { return reinterpret_cast<VkGeometryNV const*>(this); }
+};
+struct AccelerationStructureInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureTypeNV type;
+    VkBuildAccelerationStructureFlagsNV flags;
+    uint32_t instanceCount;
+    uint32_t geometryCount;
+    GeometryNV* pGeometries{};
+
+    AccelerationStructureInfoNV(const VkAccelerationStructureInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    AccelerationStructureInfoNV(const AccelerationStructureInfoNV& copy_src);
+    AccelerationStructureInfoNV& operator=(const AccelerationStructureInfoNV& copy_src);
+    AccelerationStructureInfoNV();
+    ~AccelerationStructureInfoNV();
+    void initialize(const VkAccelerationStructureInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureInfoNV* ptr() { return reinterpret_cast<VkAccelerationStructureInfoNV*>(this); }
+    VkAccelerationStructureInfoNV const* ptr() const { return reinterpret_cast<VkAccelerationStructureInfoNV const*>(this); }
+};
+struct AccelerationStructureCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize compactedSize;
+    AccelerationStructureInfoNV info;
+
+    AccelerationStructureCreateInfoNV(const VkAccelerationStructureCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    AccelerationStructureCreateInfoNV(const AccelerationStructureCreateInfoNV& copy_src);
+    AccelerationStructureCreateInfoNV& operator=(const AccelerationStructureCreateInfoNV& copy_src);
+    AccelerationStructureCreateInfoNV();
+    ~AccelerationStructureCreateInfoNV();
+    void initialize(const VkAccelerationStructureCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureCreateInfoNV* ptr() { return reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this); }
+    VkAccelerationStructureCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureCreateInfoNV const*>(this);
+    }
+};
+struct BindAccelerationStructureMemoryInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureNV accelerationStructure;
+    VkDeviceMemory memory;
+    VkDeviceSize memoryOffset;
+    uint32_t deviceIndexCount;
+    const uint32_t* pDeviceIndices{};
+
+    BindAccelerationStructureMemoryInfoNV(const VkBindAccelerationStructureMemoryInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    BindAccelerationStructureMemoryInfoNV(const BindAccelerationStructureMemoryInfoNV& copy_src);
+    BindAccelerationStructureMemoryInfoNV& operator=(const BindAccelerationStructureMemoryInfoNV& copy_src);
+    BindAccelerationStructureMemoryInfoNV();
+    ~BindAccelerationStructureMemoryInfoNV();
+    void initialize(const VkBindAccelerationStructureMemoryInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BindAccelerationStructureMemoryInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkBindAccelerationStructureMemoryInfoNV* ptr() { return reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(this); }
+    VkBindAccelerationStructureMemoryInfoNV const* ptr() const {
+        return reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV const*>(this);
+    }
+};
+struct WriteDescriptorSetAccelerationStructureNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t accelerationStructureCount;
+    VkAccelerationStructureNV* pAccelerationStructures{};
+
+    WriteDescriptorSetAccelerationStructureNV(const VkWriteDescriptorSetAccelerationStructureNV* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    WriteDescriptorSetAccelerationStructureNV(const WriteDescriptorSetAccelerationStructureNV& copy_src);
+    WriteDescriptorSetAccelerationStructureNV& operator=(const WriteDescriptorSetAccelerationStructureNV& copy_src);
+    WriteDescriptorSetAccelerationStructureNV();
+    ~WriteDescriptorSetAccelerationStructureNV();
+    void initialize(const VkWriteDescriptorSetAccelerationStructureNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const WriteDescriptorSetAccelerationStructureNV* copy_src, PNextCopyState* copy_state = {});
+    VkWriteDescriptorSetAccelerationStructureNV* ptr() {
+        return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this);
+    }
+    VkWriteDescriptorSetAccelerationStructureNV const* ptr() const {
+        return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV const*>(this);
+    }
+};
+struct AccelerationStructureMemoryRequirementsInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureMemoryRequirementsTypeNV type;
+    VkAccelerationStructureNV accelerationStructure;
+
+    AccelerationStructureMemoryRequirementsInfoNV(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureMemoryRequirementsInfoNV(const AccelerationStructureMemoryRequirementsInfoNV& copy_src);
+    AccelerationStructureMemoryRequirementsInfoNV& operator=(const AccelerationStructureMemoryRequirementsInfoNV& copy_src);
+    AccelerationStructureMemoryRequirementsInfoNV();
+    ~AccelerationStructureMemoryRequirementsInfoNV();
+    void initialize(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureMemoryRequirementsInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureMemoryRequirementsInfoNV* ptr() {
+        return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(this);
+    }
+    VkAccelerationStructureMemoryRequirementsInfoNV const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceRayTracingPropertiesNV {
+    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;
+
+    PhysicalDeviceRayTracingPropertiesNV(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDeviceRayTracingPropertiesNV(const PhysicalDeviceRayTracingPropertiesNV& copy_src);
+    PhysicalDeviceRayTracingPropertiesNV& operator=(const PhysicalDeviceRayTracingPropertiesNV& copy_src);
+    PhysicalDeviceRayTracingPropertiesNV();
+    ~PhysicalDeviceRayTracingPropertiesNV();
+    void initialize(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRayTracingPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingPropertiesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(this); }
+    VkPhysicalDeviceRayTracingPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV const*>(this);
+    }
+};
+struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 representativeFragmentTest;
+
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV(const PhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src);
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=(
+        const PhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src);
+    PhysicalDeviceRepresentativeFragmentTestFeaturesNV();
+    ~PhysicalDeviceRepresentativeFragmentTestFeaturesNV();
+    void initialize(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRepresentativeFragmentTestFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const*>(this);
+    }
+};
+struct PipelineRepresentativeFragmentTestStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 representativeFragmentTestEnable;
+
+    PipelineRepresentativeFragmentTestStateCreateInfoNV(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineRepresentativeFragmentTestStateCreateInfoNV(const PipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src);
+    PipelineRepresentativeFragmentTestStateCreateInfoNV& operator=(
+        const PipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src);
+    PipelineRepresentativeFragmentTestStateCreateInfoNV();
+    ~PipelineRepresentativeFragmentTestStateCreateInfoNV();
+    void initialize(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineRepresentativeFragmentTestStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRepresentativeFragmentTestStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this);
+    }
+    VkPipelineRepresentativeFragmentTestStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceImageViewImageFormatInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageViewType imageViewType;
+
+    PhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceImageViewImageFormatInfoEXT(const PhysicalDeviceImageViewImageFormatInfoEXT& copy_src);
+    PhysicalDeviceImageViewImageFormatInfoEXT& operator=(const PhysicalDeviceImageViewImageFormatInfoEXT& copy_src);
+    PhysicalDeviceImageViewImageFormatInfoEXT();
+    ~PhysicalDeviceImageViewImageFormatInfoEXT();
+    void initialize(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageViewImageFormatInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageViewImageFormatInfoEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(this);
+    }
+    VkPhysicalDeviceImageViewImageFormatInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT const*>(this);
+    }
+};
+struct FilterCubicImageViewImageFormatPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 filterCubic;
+    VkBool32 filterCubicMinmax;
+
+    FilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    FilterCubicImageViewImageFormatPropertiesEXT(const FilterCubicImageViewImageFormatPropertiesEXT& copy_src);
+    FilterCubicImageViewImageFormatPropertiesEXT& operator=(const FilterCubicImageViewImageFormatPropertiesEXT& copy_src);
+    FilterCubicImageViewImageFormatPropertiesEXT();
+    ~FilterCubicImageViewImageFormatPropertiesEXT();
+    void initialize(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FilterCubicImageViewImageFormatPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkFilterCubicImageViewImageFormatPropertiesEXT* ptr() {
+        return reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(this);
+    }
+    VkFilterCubicImageViewImageFormatPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT const*>(this);
+    }
+};
+struct ImportMemoryHostPointerInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+    void* pHostPointer{};
+
+    ImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    ImportMemoryHostPointerInfoEXT(const ImportMemoryHostPointerInfoEXT& copy_src);
+    ImportMemoryHostPointerInfoEXT& operator=(const ImportMemoryHostPointerInfoEXT& copy_src);
+    ImportMemoryHostPointerInfoEXT();
+    ~ImportMemoryHostPointerInfoEXT();
+    void initialize(const VkImportMemoryHostPointerInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportMemoryHostPointerInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryHostPointerInfoEXT* ptr() { return reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this); }
+    VkImportMemoryHostPointerInfoEXT const* ptr() const { return reinterpret_cast<VkImportMemoryHostPointerInfoEXT const*>(this); }
+};
+struct MemoryHostPointerPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryTypeBits;
+
+    MemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    MemoryHostPointerPropertiesEXT(const MemoryHostPointerPropertiesEXT& copy_src);
+    MemoryHostPointerPropertiesEXT& operator=(const MemoryHostPointerPropertiesEXT& copy_src);
+    MemoryHostPointerPropertiesEXT();
+    ~MemoryHostPointerPropertiesEXT();
+    void initialize(const VkMemoryHostPointerPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryHostPointerPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryHostPointerPropertiesEXT* ptr() { return reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this); }
+    VkMemoryHostPointerPropertiesEXT const* ptr() const { return reinterpret_cast<VkMemoryHostPointerPropertiesEXT const*>(this); }
+};
+struct PhysicalDeviceExternalMemoryHostPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize minImportedHostPointerAlignment;
+
+    PhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExternalMemoryHostPropertiesEXT(const PhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src);
+    PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=(const PhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src);
+    PhysicalDeviceExternalMemoryHostPropertiesEXT();
+    ~PhysicalDeviceExternalMemoryHostPropertiesEXT();
+    void initialize(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExternalMemoryHostPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT const*>(this);
+    }
+};
+struct PipelineCompilerControlCreateInfoAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCompilerControlFlagsAMD compilerControlFlags;
+
+    PipelineCompilerControlCreateInfoAMD(const VkPipelineCompilerControlCreateInfoAMD* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PipelineCompilerControlCreateInfoAMD(const PipelineCompilerControlCreateInfoAMD& copy_src);
+    PipelineCompilerControlCreateInfoAMD& operator=(const PipelineCompilerControlCreateInfoAMD& copy_src);
+    PipelineCompilerControlCreateInfoAMD();
+    ~PipelineCompilerControlCreateInfoAMD();
+    void initialize(const VkPipelineCompilerControlCreateInfoAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineCompilerControlCreateInfoAMD* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCompilerControlCreateInfoAMD* ptr() { return reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(this); }
+    VkPipelineCompilerControlCreateInfoAMD const* ptr() const {
+        return reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD const*>(this);
+    }
+};
+struct PhysicalDeviceShaderCorePropertiesAMD {
+    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;
+
+    PhysicalDeviceShaderCorePropertiesAMD(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDeviceShaderCorePropertiesAMD(const PhysicalDeviceShaderCorePropertiesAMD& copy_src);
+    PhysicalDeviceShaderCorePropertiesAMD& operator=(const PhysicalDeviceShaderCorePropertiesAMD& copy_src);
+    PhysicalDeviceShaderCorePropertiesAMD();
+    ~PhysicalDeviceShaderCorePropertiesAMD();
+    void initialize(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderCorePropertiesAMD* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderCorePropertiesAMD* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this); }
+    VkPhysicalDeviceShaderCorePropertiesAMD const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD const*>(this);
+    }
+};
+struct DeviceMemoryOverallocationCreateInfoAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMemoryOverallocationBehaviorAMD overallocationBehavior;
+
+    DeviceMemoryOverallocationCreateInfoAMD(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DeviceMemoryOverallocationCreateInfoAMD(const DeviceMemoryOverallocationCreateInfoAMD& copy_src);
+    DeviceMemoryOverallocationCreateInfoAMD& operator=(const DeviceMemoryOverallocationCreateInfoAMD& copy_src);
+    DeviceMemoryOverallocationCreateInfoAMD();
+    ~DeviceMemoryOverallocationCreateInfoAMD();
+    void initialize(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceMemoryOverallocationCreateInfoAMD* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceMemoryOverallocationCreateInfoAMD* ptr() { return reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(this); }
+    VkDeviceMemoryOverallocationCreateInfoAMD const* ptr() const {
+        return reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD const*>(this);
+    }
+};
+struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxVertexAttribDivisor;
+
+    PhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceVertexAttributeDivisorPropertiesEXT(const PhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src);
+    PhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=(const PhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src);
+    PhysicalDeviceVertexAttributeDivisorPropertiesEXT();
+    ~PhysicalDeviceVertexAttributeDivisorPropertiesEXT();
+    void initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVertexAttributeDivisorPropertiesEXT* 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 PresentFrameTokenGGP {
+    VkStructureType sType;
+    const void* pNext{};
+    GgpFrameToken frameToken;
+
+    PresentFrameTokenGGP(const VkPresentFrameTokenGGP* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PresentFrameTokenGGP(const PresentFrameTokenGGP& copy_src);
+    PresentFrameTokenGGP& operator=(const PresentFrameTokenGGP& copy_src);
+    PresentFrameTokenGGP();
+    ~PresentFrameTokenGGP();
+    void initialize(const VkPresentFrameTokenGGP* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PresentFrameTokenGGP* 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 PhysicalDeviceComputeShaderDerivativesFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 computeDerivativeGroupQuads;
+    VkBool32 computeDerivativeGroupLinear;
+
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV(const PhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src);
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=(const PhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src);
+    PhysicalDeviceComputeShaderDerivativesFeaturesNV();
+    ~PhysicalDeviceComputeShaderDerivativesFeaturesNV();
+    void initialize(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceComputeShaderDerivativesFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceMeshShaderFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 taskShader;
+    VkBool32 meshShader;
+
+    PhysicalDeviceMeshShaderFeaturesNV(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    PhysicalDeviceMeshShaderFeaturesNV(const PhysicalDeviceMeshShaderFeaturesNV& copy_src);
+    PhysicalDeviceMeshShaderFeaturesNV& operator=(const PhysicalDeviceMeshShaderFeaturesNV& copy_src);
+    PhysicalDeviceMeshShaderFeaturesNV();
+    ~PhysicalDeviceMeshShaderFeaturesNV();
+    void initialize(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMeshShaderFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMeshShaderFeaturesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this); }
+    VkPhysicalDeviceMeshShaderFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceMeshShaderPropertiesNV {
+    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;
+
+    PhysicalDeviceMeshShaderPropertiesNV(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDeviceMeshShaderPropertiesNV(const PhysicalDeviceMeshShaderPropertiesNV& copy_src);
+    PhysicalDeviceMeshShaderPropertiesNV& operator=(const PhysicalDeviceMeshShaderPropertiesNV& copy_src);
+    PhysicalDeviceMeshShaderPropertiesNV();
+    ~PhysicalDeviceMeshShaderPropertiesNV();
+    void initialize(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMeshShaderPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMeshShaderPropertiesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this); }
+    VkPhysicalDeviceMeshShaderPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV const*>(this);
+    }
+};
+struct PhysicalDeviceShaderImageFootprintFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 imageFootprint;
+
+    PhysicalDeviceShaderImageFootprintFeaturesNV(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderImageFootprintFeaturesNV(const PhysicalDeviceShaderImageFootprintFeaturesNV& copy_src);
+    PhysicalDeviceShaderImageFootprintFeaturesNV& operator=(const PhysicalDeviceShaderImageFootprintFeaturesNV& copy_src);
+    PhysicalDeviceShaderImageFootprintFeaturesNV();
+    ~PhysicalDeviceShaderImageFootprintFeaturesNV();
+    void initialize(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderImageFootprintFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderImageFootprintFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceShaderImageFootprintFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV const*>(this);
+    }
+};
+struct PipelineViewportExclusiveScissorStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t exclusiveScissorCount;
+    const VkRect2D* pExclusiveScissors{};
+
+    PipelineViewportExclusiveScissorStateCreateInfoNV(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineViewportExclusiveScissorStateCreateInfoNV(const PipelineViewportExclusiveScissorStateCreateInfoNV& copy_src);
+    PipelineViewportExclusiveScissorStateCreateInfoNV& operator=(const PipelineViewportExclusiveScissorStateCreateInfoNV& copy_src);
+    PipelineViewportExclusiveScissorStateCreateInfoNV();
+    ~PipelineViewportExclusiveScissorStateCreateInfoNV();
+    void initialize(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineViewportExclusiveScissorStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportExclusiveScissorStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this);
+    }
+    VkPipelineViewportExclusiveScissorStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceExclusiveScissorFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 exclusiveScissor;
+
+    PhysicalDeviceExclusiveScissorFeaturesNV(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExclusiveScissorFeaturesNV(const PhysicalDeviceExclusiveScissorFeaturesNV& copy_src);
+    PhysicalDeviceExclusiveScissorFeaturesNV& operator=(const PhysicalDeviceExclusiveScissorFeaturesNV& copy_src);
+    PhysicalDeviceExclusiveScissorFeaturesNV();
+    ~PhysicalDeviceExclusiveScissorFeaturesNV();
+    void initialize(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExclusiveScissorFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExclusiveScissorFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceExclusiveScissorFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV const*>(this);
+    }
+};
+struct QueueFamilyCheckpointPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineStageFlags checkpointExecutionStageMask;
+
+    QueueFamilyCheckpointPropertiesNV(const VkQueueFamilyCheckpointPropertiesNV* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    QueueFamilyCheckpointPropertiesNV(const QueueFamilyCheckpointPropertiesNV& copy_src);
+    QueueFamilyCheckpointPropertiesNV& operator=(const QueueFamilyCheckpointPropertiesNV& copy_src);
+    QueueFamilyCheckpointPropertiesNV();
+    ~QueueFamilyCheckpointPropertiesNV();
+    void initialize(const VkQueueFamilyCheckpointPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const QueueFamilyCheckpointPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyCheckpointPropertiesNV* ptr() { return reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this); }
+    VkQueueFamilyCheckpointPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV const*>(this);
+    }
+};
+struct CheckpointDataNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineStageFlagBits stage;
+    void* pCheckpointMarker{};
+
+    CheckpointDataNV(const VkCheckpointDataNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CheckpointDataNV(const CheckpointDataNV& copy_src);
+    CheckpointDataNV& operator=(const CheckpointDataNV& copy_src);
+    CheckpointDataNV();
+    ~CheckpointDataNV();
+    void initialize(const VkCheckpointDataNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CheckpointDataNV* copy_src, PNextCopyState* copy_state = {});
+    VkCheckpointDataNV* ptr() { return reinterpret_cast<VkCheckpointDataNV*>(this); }
+    VkCheckpointDataNV const* ptr() const { return reinterpret_cast<VkCheckpointDataNV const*>(this); }
+};
+struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderIntegerFunctions2;
+
+    PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src);
+    PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=(
+        const PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src);
+    PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL();
+    ~PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL();
+    void initialize(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(this);
+    }
+    VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const*>(this);
+    }
+};
+union PerformanceValueDataINTEL {
+    uint32_t value32;
+    uint64_t value64;
+    float valueFloat;
+    VkBool32 valueBool;
+    const char* valueString{};
+
+    PerformanceValueDataINTEL(const VkPerformanceValueDataINTEL* in_struct, PNextCopyState* copy_state = {});
+    PerformanceValueDataINTEL(const PerformanceValueDataINTEL& copy_src);
+    PerformanceValueDataINTEL& operator=(const PerformanceValueDataINTEL& copy_src);
+    PerformanceValueDataINTEL();
+    ~PerformanceValueDataINTEL();
+    void initialize(const VkPerformanceValueDataINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PerformanceValueDataINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceValueDataINTEL* ptr() { return reinterpret_cast<VkPerformanceValueDataINTEL*>(this); }
+    VkPerformanceValueDataINTEL const* ptr() const { return reinterpret_cast<VkPerformanceValueDataINTEL const*>(this); }
+};
+struct InitializePerformanceApiInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    void* pUserData{};
+
+    InitializePerformanceApiInfoINTEL(const VkInitializePerformanceApiInfoINTEL* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    InitializePerformanceApiInfoINTEL(const InitializePerformanceApiInfoINTEL& copy_src);
+    InitializePerformanceApiInfoINTEL& operator=(const InitializePerformanceApiInfoINTEL& copy_src);
+    InitializePerformanceApiInfoINTEL();
+    ~InitializePerformanceApiInfoINTEL();
+    void initialize(const VkInitializePerformanceApiInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const InitializePerformanceApiInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkInitializePerformanceApiInfoINTEL* ptr() { return reinterpret_cast<VkInitializePerformanceApiInfoINTEL*>(this); }
+    VkInitializePerformanceApiInfoINTEL const* ptr() const {
+        return reinterpret_cast<VkInitializePerformanceApiInfoINTEL const*>(this);
+    }
+};
+struct QueryPoolPerformanceQueryCreateInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueryPoolSamplingModeINTEL performanceCountersSampling;
+
+    QueryPoolPerformanceQueryCreateInfoINTEL(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    QueryPoolPerformanceQueryCreateInfoINTEL(const QueryPoolPerformanceQueryCreateInfoINTEL& copy_src);
+    QueryPoolPerformanceQueryCreateInfoINTEL& operator=(const QueryPoolPerformanceQueryCreateInfoINTEL& copy_src);
+    QueryPoolPerformanceQueryCreateInfoINTEL();
+    ~QueryPoolPerformanceQueryCreateInfoINTEL();
+    void initialize(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const QueryPoolPerformanceQueryCreateInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkQueryPoolPerformanceQueryCreateInfoINTEL* ptr() {
+        return reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(this);
+    }
+    VkQueryPoolPerformanceQueryCreateInfoINTEL const* ptr() const {
+        return reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL const*>(this);
+    }
+};
+struct PerformanceMarkerInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t marker;
+
+    PerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    PerformanceMarkerInfoINTEL(const PerformanceMarkerInfoINTEL& copy_src);
+    PerformanceMarkerInfoINTEL& operator=(const PerformanceMarkerInfoINTEL& copy_src);
+    PerformanceMarkerInfoINTEL();
+    ~PerformanceMarkerInfoINTEL();
+    void initialize(const VkPerformanceMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PerformanceMarkerInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceMarkerInfoINTEL* ptr() { return reinterpret_cast<VkPerformanceMarkerInfoINTEL*>(this); }
+    VkPerformanceMarkerInfoINTEL const* ptr() const { return reinterpret_cast<VkPerformanceMarkerInfoINTEL const*>(this); }
+};
+struct PerformanceStreamMarkerInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t marker;
+
+    PerformanceStreamMarkerInfoINTEL(const VkPerformanceStreamMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    PerformanceStreamMarkerInfoINTEL(const PerformanceStreamMarkerInfoINTEL& copy_src);
+    PerformanceStreamMarkerInfoINTEL& operator=(const PerformanceStreamMarkerInfoINTEL& copy_src);
+    PerformanceStreamMarkerInfoINTEL();
+    ~PerformanceStreamMarkerInfoINTEL();
+    void initialize(const VkPerformanceStreamMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PerformanceStreamMarkerInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceStreamMarkerInfoINTEL* ptr() { return reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>(this); }
+    VkPerformanceStreamMarkerInfoINTEL const* ptr() const {
+        return reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL const*>(this);
+    }
+};
+struct PerformanceOverrideInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPerformanceOverrideTypeINTEL type;
+    VkBool32 enable;
+    uint64_t parameter;
+
+    PerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    PerformanceOverrideInfoINTEL(const PerformanceOverrideInfoINTEL& copy_src);
+    PerformanceOverrideInfoINTEL& operator=(const PerformanceOverrideInfoINTEL& copy_src);
+    PerformanceOverrideInfoINTEL();
+    ~PerformanceOverrideInfoINTEL();
+    void initialize(const VkPerformanceOverrideInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PerformanceOverrideInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceOverrideInfoINTEL* ptr() { return reinterpret_cast<VkPerformanceOverrideInfoINTEL*>(this); }
+    VkPerformanceOverrideInfoINTEL const* ptr() const { return reinterpret_cast<VkPerformanceOverrideInfoINTEL const*>(this); }
+};
+struct PerformanceConfigurationAcquireInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPerformanceConfigurationTypeINTEL type;
+
+    PerformanceConfigurationAcquireInfoINTEL(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PerformanceConfigurationAcquireInfoINTEL(const PerformanceConfigurationAcquireInfoINTEL& copy_src);
+    PerformanceConfigurationAcquireInfoINTEL& operator=(const PerformanceConfigurationAcquireInfoINTEL& copy_src);
+    PerformanceConfigurationAcquireInfoINTEL();
+    ~PerformanceConfigurationAcquireInfoINTEL();
+    void initialize(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PerformanceConfigurationAcquireInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceConfigurationAcquireInfoINTEL* ptr() {
+        return reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>(this);
+    }
+    VkPerformanceConfigurationAcquireInfoINTEL const* ptr() const {
+        return reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL const*>(this);
+    }
+};
+struct PhysicalDevicePCIBusInfoPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t pciDomain;
+    uint32_t pciBus;
+    uint32_t pciDevice;
+    uint32_t pciFunction;
+
+    PhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDevicePCIBusInfoPropertiesEXT(const PhysicalDevicePCIBusInfoPropertiesEXT& copy_src);
+    PhysicalDevicePCIBusInfoPropertiesEXT& operator=(const PhysicalDevicePCIBusInfoPropertiesEXT& copy_src);
+    PhysicalDevicePCIBusInfoPropertiesEXT();
+    ~PhysicalDevicePCIBusInfoPropertiesEXT();
+    void initialize(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePCIBusInfoPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePCIBusInfoPropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this); }
+    VkPhysicalDevicePCIBusInfoPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT const*>(this);
+    }
+};
+struct DisplayNativeHdrSurfaceCapabilitiesAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 localDimmingSupport;
+
+    DisplayNativeHdrSurfaceCapabilitiesAMD(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DisplayNativeHdrSurfaceCapabilitiesAMD(const DisplayNativeHdrSurfaceCapabilitiesAMD& copy_src);
+    DisplayNativeHdrSurfaceCapabilitiesAMD& operator=(const DisplayNativeHdrSurfaceCapabilitiesAMD& copy_src);
+    DisplayNativeHdrSurfaceCapabilitiesAMD();
+    ~DisplayNativeHdrSurfaceCapabilitiesAMD();
+    void initialize(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DisplayNativeHdrSurfaceCapabilitiesAMD* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayNativeHdrSurfaceCapabilitiesAMD* ptr() { return reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(this); }
+    VkDisplayNativeHdrSurfaceCapabilitiesAMD const* ptr() const {
+        return reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD const*>(this);
+    }
+};
+struct SwapchainDisplayNativeHdrCreateInfoAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 localDimmingEnable;
+
+    SwapchainDisplayNativeHdrCreateInfoAMD(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SwapchainDisplayNativeHdrCreateInfoAMD(const SwapchainDisplayNativeHdrCreateInfoAMD& copy_src);
+    SwapchainDisplayNativeHdrCreateInfoAMD& operator=(const SwapchainDisplayNativeHdrCreateInfoAMD& copy_src);
+    SwapchainDisplayNativeHdrCreateInfoAMD();
+    ~SwapchainDisplayNativeHdrCreateInfoAMD();
+    void initialize(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SwapchainDisplayNativeHdrCreateInfoAMD* 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 ImagePipeSurfaceCreateInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImagePipeSurfaceCreateFlagsFUCHSIA flags;
+    zx_handle_t imagePipeHandle;
+
+    ImagePipeSurfaceCreateInfoFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    ImagePipeSurfaceCreateInfoFUCHSIA(const ImagePipeSurfaceCreateInfoFUCHSIA& copy_src);
+    ImagePipeSurfaceCreateInfoFUCHSIA& operator=(const ImagePipeSurfaceCreateInfoFUCHSIA& copy_src);
+    ImagePipeSurfaceCreateInfoFUCHSIA();
+    ~ImagePipeSurfaceCreateInfoFUCHSIA();
+    void initialize(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImagePipeSurfaceCreateInfoFUCHSIA* 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 PhysicalDeviceFragmentDensityMapFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentDensityMap;
+    VkBool32 fragmentDensityMapDynamic;
+    VkBool32 fragmentDensityMapNonSubsampledImages;
+
+    PhysicalDeviceFragmentDensityMapFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentDensityMapFeaturesEXT(const PhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src);
+    PhysicalDeviceFragmentDensityMapFeaturesEXT& operator=(const PhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src);
+    PhysicalDeviceFragmentDensityMapFeaturesEXT();
+    ~PhysicalDeviceFragmentDensityMapFeaturesEXT();
+    void initialize(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentDensityMapFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMapFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMapFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceFragmentDensityMapPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D minFragmentDensityTexelSize;
+    VkExtent2D maxFragmentDensityTexelSize;
+    VkBool32 fragmentDensityInvocations;
+
+    PhysicalDeviceFragmentDensityMapPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentDensityMapPropertiesEXT(const PhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src);
+    PhysicalDeviceFragmentDensityMapPropertiesEXT& operator=(const PhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src);
+    PhysicalDeviceFragmentDensityMapPropertiesEXT();
+    ~PhysicalDeviceFragmentDensityMapPropertiesEXT();
+    void initialize(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentDensityMapPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMapPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMapPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT const*>(this);
+    }
+};
+struct RenderPassFragmentDensityMapCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAttachmentReference fragmentDensityMapAttachment;
+
+    RenderPassFragmentDensityMapCreateInfoEXT(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderPassFragmentDensityMapCreateInfoEXT(const RenderPassFragmentDensityMapCreateInfoEXT& copy_src);
+    RenderPassFragmentDensityMapCreateInfoEXT& operator=(const RenderPassFragmentDensityMapCreateInfoEXT& copy_src);
+    RenderPassFragmentDensityMapCreateInfoEXT();
+    ~RenderPassFragmentDensityMapCreateInfoEXT();
+    void initialize(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassFragmentDensityMapCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassFragmentDensityMapCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(this);
+    }
+    VkRenderPassFragmentDensityMapCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT const*>(this);
+    }
+};
+struct PhysicalDeviceShaderCoreProperties2AMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
+    uint32_t activeComputeUnitCount;
+
+    PhysicalDeviceShaderCoreProperties2AMD(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderCoreProperties2AMD(const PhysicalDeviceShaderCoreProperties2AMD& copy_src);
+    PhysicalDeviceShaderCoreProperties2AMD& operator=(const PhysicalDeviceShaderCoreProperties2AMD& copy_src);
+    PhysicalDeviceShaderCoreProperties2AMD();
+    ~PhysicalDeviceShaderCoreProperties2AMD();
+    void initialize(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderCoreProperties2AMD* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderCoreProperties2AMD* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(this); }
+    VkPhysicalDeviceShaderCoreProperties2AMD const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD const*>(this);
+    }
+};
+struct PhysicalDeviceCoherentMemoryFeaturesAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 deviceCoherentMemory;
+
+    PhysicalDeviceCoherentMemoryFeaturesAMD(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCoherentMemoryFeaturesAMD(const PhysicalDeviceCoherentMemoryFeaturesAMD& copy_src);
+    PhysicalDeviceCoherentMemoryFeaturesAMD& operator=(const PhysicalDeviceCoherentMemoryFeaturesAMD& copy_src);
+    PhysicalDeviceCoherentMemoryFeaturesAMD();
+    ~PhysicalDeviceCoherentMemoryFeaturesAMD();
+    void initialize(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCoherentMemoryFeaturesAMD* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCoherentMemoryFeaturesAMD* ptr() { return reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(this); }
+    VkPhysicalDeviceCoherentMemoryFeaturesAMD const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD const*>(this);
+    }
+};
+struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderImageInt64Atomics;
+    VkBool32 sparseImageInt64Atomics;
+
+    PhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const PhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src);
+    PhysicalDeviceShaderImageAtomicInt64FeaturesEXT& operator=(const PhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src);
+    PhysicalDeviceShaderImageAtomicInt64FeaturesEXT();
+    ~PhysicalDeviceShaderImageAtomicInt64FeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderImageAtomicInt64FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceMemoryBudgetPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];
+    VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];
+
+    PhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMemoryBudgetPropertiesEXT(const PhysicalDeviceMemoryBudgetPropertiesEXT& copy_src);
+    PhysicalDeviceMemoryBudgetPropertiesEXT& operator=(const PhysicalDeviceMemoryBudgetPropertiesEXT& copy_src);
+    PhysicalDeviceMemoryBudgetPropertiesEXT();
+    ~PhysicalDeviceMemoryBudgetPropertiesEXT();
+    void initialize(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMemoryBudgetPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMemoryBudgetPropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(this); }
+    VkPhysicalDeviceMemoryBudgetPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceMemoryPriorityFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 memoryPriority;
+
+    PhysicalDeviceMemoryPriorityFeaturesEXT(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMemoryPriorityFeaturesEXT(const PhysicalDeviceMemoryPriorityFeaturesEXT& copy_src);
+    PhysicalDeviceMemoryPriorityFeaturesEXT& operator=(const PhysicalDeviceMemoryPriorityFeaturesEXT& copy_src);
+    PhysicalDeviceMemoryPriorityFeaturesEXT();
+    ~PhysicalDeviceMemoryPriorityFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMemoryPriorityFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMemoryPriorityFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(this); }
+    VkPhysicalDeviceMemoryPriorityFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT const*>(this);
+    }
+};
+struct MemoryPriorityAllocateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    float priority;
+
+    MemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    MemoryPriorityAllocateInfoEXT(const MemoryPriorityAllocateInfoEXT& copy_src);
+    MemoryPriorityAllocateInfoEXT& operator=(const MemoryPriorityAllocateInfoEXT& copy_src);
+    MemoryPriorityAllocateInfoEXT();
+    ~MemoryPriorityAllocateInfoEXT();
+    void initialize(const VkMemoryPriorityAllocateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryPriorityAllocateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryPriorityAllocateInfoEXT* ptr() { return reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(this); }
+    VkMemoryPriorityAllocateInfoEXT const* ptr() const { return reinterpret_cast<VkMemoryPriorityAllocateInfoEXT const*>(this); }
+};
+struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 dedicatedAllocationImageAliasing;
+
+    PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+        const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+        const PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src);
+    PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=(
+        const PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src);
+    PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV();
+    ~PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV();
+    void initialize(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceBufferDeviceAddressFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 bufferDeviceAddress;
+    VkBool32 bufferDeviceAddressCaptureReplay;
+    VkBool32 bufferDeviceAddressMultiDevice;
+
+    PhysicalDeviceBufferDeviceAddressFeaturesEXT(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceBufferDeviceAddressFeaturesEXT(const PhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src);
+    PhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=(const PhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src);
+    PhysicalDeviceBufferDeviceAddressFeaturesEXT();
+    ~PhysicalDeviceBufferDeviceAddressFeaturesEXT();
+    void initialize(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceBufferDeviceAddressFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const*>(this);
+    }
+};
+struct BufferDeviceAddressCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceAddress deviceAddress;
+
+    BufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    BufferDeviceAddressCreateInfoEXT(const BufferDeviceAddressCreateInfoEXT& copy_src);
+    BufferDeviceAddressCreateInfoEXT& operator=(const BufferDeviceAddressCreateInfoEXT& copy_src);
+    BufferDeviceAddressCreateInfoEXT();
+    ~BufferDeviceAddressCreateInfoEXT();
+    void initialize(const VkBufferDeviceAddressCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferDeviceAddressCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkBufferDeviceAddressCreateInfoEXT* ptr() { return reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(this); }
+    VkBufferDeviceAddressCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT const*>(this);
+    }
+};
+struct ValidationFeaturesEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t enabledValidationFeatureCount;
+    const VkValidationFeatureEnableEXT* pEnabledValidationFeatures{};
+    uint32_t disabledValidationFeatureCount;
+    const VkValidationFeatureDisableEXT* pDisabledValidationFeatures{};
+
+    ValidationFeaturesEXT(const VkValidationFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ValidationFeaturesEXT(const ValidationFeaturesEXT& copy_src);
+    ValidationFeaturesEXT& operator=(const ValidationFeaturesEXT& copy_src);
+    ValidationFeaturesEXT();
+    ~ValidationFeaturesEXT();
+    void initialize(const VkValidationFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ValidationFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkValidationFeaturesEXT* ptr() { return reinterpret_cast<VkValidationFeaturesEXT*>(this); }
+    VkValidationFeaturesEXT const* ptr() const { return reinterpret_cast<VkValidationFeaturesEXT const*>(this); }
+};
+struct CooperativeMatrixPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t MSize;
+    uint32_t NSize;
+    uint32_t KSize;
+    VkComponentTypeNV AType;
+    VkComponentTypeNV BType;
+    VkComponentTypeNV CType;
+    VkComponentTypeNV DType;
+    VkScopeNV scope;
+
+    CooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    CooperativeMatrixPropertiesNV(const CooperativeMatrixPropertiesNV& copy_src);
+    CooperativeMatrixPropertiesNV& operator=(const CooperativeMatrixPropertiesNV& copy_src);
+    CooperativeMatrixPropertiesNV();
+    ~CooperativeMatrixPropertiesNV();
+    void initialize(const VkCooperativeMatrixPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CooperativeMatrixPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkCooperativeMatrixPropertiesNV* ptr() { return reinterpret_cast<VkCooperativeMatrixPropertiesNV*>(this); }
+    VkCooperativeMatrixPropertiesNV const* ptr() const { return reinterpret_cast<VkCooperativeMatrixPropertiesNV const*>(this); }
+};
+struct PhysicalDeviceCooperativeMatrixFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cooperativeMatrix;
+    VkBool32 cooperativeMatrixRobustBufferAccess;
+
+    PhysicalDeviceCooperativeMatrixFeaturesNV(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCooperativeMatrixFeaturesNV(const PhysicalDeviceCooperativeMatrixFeaturesNV& copy_src);
+    PhysicalDeviceCooperativeMatrixFeaturesNV& operator=(const PhysicalDeviceCooperativeMatrixFeaturesNV& copy_src);
+    PhysicalDeviceCooperativeMatrixFeaturesNV();
+    ~PhysicalDeviceCooperativeMatrixFeaturesNV();
+    void initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCooperativeMatrixFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeMatrixFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCooperativeMatrixFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceCooperativeMatrixPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkShaderStageFlags cooperativeMatrixSupportedStages;
+
+    PhysicalDeviceCooperativeMatrixPropertiesNV(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCooperativeMatrixPropertiesNV(const PhysicalDeviceCooperativeMatrixPropertiesNV& copy_src);
+    PhysicalDeviceCooperativeMatrixPropertiesNV& operator=(const PhysicalDeviceCooperativeMatrixPropertiesNV& copy_src);
+    PhysicalDeviceCooperativeMatrixPropertiesNV();
+    ~PhysicalDeviceCooperativeMatrixPropertiesNV();
+    void initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCooperativeMatrixPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeMatrixPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceCooperativeMatrixPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV const*>(this);
+    }
+};
+struct PhysicalDeviceCoverageReductionModeFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 coverageReductionMode;
+
+    PhysicalDeviceCoverageReductionModeFeaturesNV(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCoverageReductionModeFeaturesNV(const PhysicalDeviceCoverageReductionModeFeaturesNV& copy_src);
+    PhysicalDeviceCoverageReductionModeFeaturesNV& operator=(const PhysicalDeviceCoverageReductionModeFeaturesNV& copy_src);
+    PhysicalDeviceCoverageReductionModeFeaturesNV();
+    ~PhysicalDeviceCoverageReductionModeFeaturesNV();
+    void initialize(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCoverageReductionModeFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCoverageReductionModeFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCoverageReductionModeFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV const*>(this);
+    }
+};
+struct PipelineCoverageReductionStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCoverageReductionStateCreateFlagsNV flags;
+    VkCoverageReductionModeNV coverageReductionMode;
+
+    PipelineCoverageReductionStateCreateInfoNV(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineCoverageReductionStateCreateInfoNV(const PipelineCoverageReductionStateCreateInfoNV& copy_src);
+    PipelineCoverageReductionStateCreateInfoNV& operator=(const PipelineCoverageReductionStateCreateInfoNV& copy_src);
+    PipelineCoverageReductionStateCreateInfoNV();
+    ~PipelineCoverageReductionStateCreateInfoNV();
+    void initialize(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineCoverageReductionStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCoverageReductionStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(this);
+    }
+    VkPipelineCoverageReductionStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV const*>(this);
+    }
+};
+struct FramebufferMixedSamplesCombinationNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkCoverageReductionModeNV coverageReductionMode;
+    VkSampleCountFlagBits rasterizationSamples;
+    VkSampleCountFlags depthStencilSamples;
+    VkSampleCountFlags colorSamples;
+
+    FramebufferMixedSamplesCombinationNV(const VkFramebufferMixedSamplesCombinationNV* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    FramebufferMixedSamplesCombinationNV(const FramebufferMixedSamplesCombinationNV& copy_src);
+    FramebufferMixedSamplesCombinationNV& operator=(const FramebufferMixedSamplesCombinationNV& copy_src);
+    FramebufferMixedSamplesCombinationNV();
+    ~FramebufferMixedSamplesCombinationNV();
+    void initialize(const VkFramebufferMixedSamplesCombinationNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FramebufferMixedSamplesCombinationNV* copy_src, PNextCopyState* copy_state = {});
+    VkFramebufferMixedSamplesCombinationNV* ptr() { return reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>(this); }
+    VkFramebufferMixedSamplesCombinationNV const* ptr() const {
+        return reinterpret_cast<VkFramebufferMixedSamplesCombinationNV const*>(this);
+    }
+};
+struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentShaderSampleInterlock;
+    VkBool32 fragmentShaderPixelInterlock;
+    VkBool32 fragmentShaderShadingRateInterlock;
+
+    PhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentShaderInterlockFeaturesEXT(const PhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src);
+    PhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=(const PhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src);
+    PhysicalDeviceFragmentShaderInterlockFeaturesEXT();
+    ~PhysicalDeviceFragmentShaderInterlockFeaturesEXT();
+    void initialize(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentShaderInterlockFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceYcbcrImageArraysFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 ycbcrImageArrays;
+
+    PhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceYcbcrImageArraysFeaturesEXT(const PhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src);
+    PhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=(const PhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src);
+    PhysicalDeviceYcbcrImageArraysFeaturesEXT();
+    ~PhysicalDeviceYcbcrImageArraysFeaturesEXT();
+    void initialize(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceYcbcrImageArraysFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceProvokingVertexFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 provokingVertexLast;
+    VkBool32 transformFeedbackPreservesProvokingVertex;
+
+    PhysicalDeviceProvokingVertexFeaturesEXT(const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceProvokingVertexFeaturesEXT(const PhysicalDeviceProvokingVertexFeaturesEXT& copy_src);
+    PhysicalDeviceProvokingVertexFeaturesEXT& operator=(const PhysicalDeviceProvokingVertexFeaturesEXT& copy_src);
+    PhysicalDeviceProvokingVertexFeaturesEXT();
+    ~PhysicalDeviceProvokingVertexFeaturesEXT();
+    void initialize(const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceProvokingVertexFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceProvokingVertexFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceProvokingVertexFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceProvokingVertexPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 provokingVertexModePerPipeline;
+    VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex;
+
+    PhysicalDeviceProvokingVertexPropertiesEXT(const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceProvokingVertexPropertiesEXT(const PhysicalDeviceProvokingVertexPropertiesEXT& copy_src);
+    PhysicalDeviceProvokingVertexPropertiesEXT& operator=(const PhysicalDeviceProvokingVertexPropertiesEXT& copy_src);
+    PhysicalDeviceProvokingVertexPropertiesEXT();
+    ~PhysicalDeviceProvokingVertexPropertiesEXT();
+    void initialize(const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceProvokingVertexPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceProvokingVertexPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceProvokingVertexPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT const*>(this);
+    }
+};
+struct PipelineRasterizationProvokingVertexStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkProvokingVertexModeEXT provokingVertexMode;
+
+    PipelineRasterizationProvokingVertexStateCreateInfoEXT(
+        const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    PipelineRasterizationProvokingVertexStateCreateInfoEXT(const PipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src);
+    PipelineRasterizationProvokingVertexStateCreateInfoEXT& operator=(
+        const PipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src);
+    PipelineRasterizationProvokingVertexStateCreateInfoEXT();
+    ~PipelineRasterizationProvokingVertexStateCreateInfoEXT();
+    void initialize(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineRasterizationProvokingVertexStateCreateInfoEXT* 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 SurfaceFullScreenExclusiveInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkFullScreenExclusiveEXT fullScreenExclusive;
+
+    SurfaceFullScreenExclusiveInfoEXT(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    SurfaceFullScreenExclusiveInfoEXT(const SurfaceFullScreenExclusiveInfoEXT& copy_src);
+    SurfaceFullScreenExclusiveInfoEXT& operator=(const SurfaceFullScreenExclusiveInfoEXT& copy_src);
+    SurfaceFullScreenExclusiveInfoEXT();
+    ~SurfaceFullScreenExclusiveInfoEXT();
+    void initialize(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SurfaceFullScreenExclusiveInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceFullScreenExclusiveInfoEXT* ptr() { return reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(this); }
+    VkSurfaceFullScreenExclusiveInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT const*>(this);
+    }
+};
+struct SurfaceCapabilitiesFullScreenExclusiveEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fullScreenExclusiveSupported;
+
+    SurfaceCapabilitiesFullScreenExclusiveEXT(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SurfaceCapabilitiesFullScreenExclusiveEXT(const SurfaceCapabilitiesFullScreenExclusiveEXT& copy_src);
+    SurfaceCapabilitiesFullScreenExclusiveEXT& operator=(const SurfaceCapabilitiesFullScreenExclusiveEXT& copy_src);
+    SurfaceCapabilitiesFullScreenExclusiveEXT();
+    ~SurfaceCapabilitiesFullScreenExclusiveEXT();
+    void initialize(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SurfaceCapabilitiesFullScreenExclusiveEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceCapabilitiesFullScreenExclusiveEXT* ptr() {
+        return reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(this);
+    }
+    VkSurfaceCapabilitiesFullScreenExclusiveEXT const* ptr() const {
+        return reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT const*>(this);
+    }
+};
+struct SurfaceFullScreenExclusiveWin32InfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    HMONITOR hmonitor;
+
+    SurfaceFullScreenExclusiveWin32InfoEXT(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SurfaceFullScreenExclusiveWin32InfoEXT(const SurfaceFullScreenExclusiveWin32InfoEXT& copy_src);
+    SurfaceFullScreenExclusiveWin32InfoEXT& operator=(const SurfaceFullScreenExclusiveWin32InfoEXT& copy_src);
+    SurfaceFullScreenExclusiveWin32InfoEXT();
+    ~SurfaceFullScreenExclusiveWin32InfoEXT();
+    void initialize(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SurfaceFullScreenExclusiveWin32InfoEXT* 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 HeadlessSurfaceCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkHeadlessSurfaceCreateFlagsEXT flags;
+
+    HeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    HeadlessSurfaceCreateInfoEXT(const HeadlessSurfaceCreateInfoEXT& copy_src);
+    HeadlessSurfaceCreateInfoEXT& operator=(const HeadlessSurfaceCreateInfoEXT& copy_src);
+    HeadlessSurfaceCreateInfoEXT();
+    ~HeadlessSurfaceCreateInfoEXT();
+    void initialize(const VkHeadlessSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const HeadlessSurfaceCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkHeadlessSurfaceCreateInfoEXT* ptr() { return reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT*>(this); }
+    VkHeadlessSurfaceCreateInfoEXT const* ptr() const { return reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT const*>(this); }
+};
+struct PhysicalDeviceShaderAtomicFloatFeaturesEXT {
+    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;
+
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT(const PhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src);
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT& operator=(const PhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src);
+    PhysicalDeviceShaderAtomicFloatFeaturesEXT();
+    ~PhysicalDeviceShaderAtomicFloatFeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderAtomicFloatFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceExtendedDynamicStateFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 extendedDynamicState;
+
+    PhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExtendedDynamicStateFeaturesEXT(const PhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src);
+    PhysicalDeviceExtendedDynamicStateFeaturesEXT& operator=(const PhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src);
+    PhysicalDeviceExtendedDynamicStateFeaturesEXT();
+    ~PhysicalDeviceExtendedDynamicStateFeaturesEXT();
+    void initialize(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExtendedDynamicStateFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceHostImageCopyFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hostImageCopy;
+
+    PhysicalDeviceHostImageCopyFeaturesEXT(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceHostImageCopyFeaturesEXT(const PhysicalDeviceHostImageCopyFeaturesEXT& copy_src);
+    PhysicalDeviceHostImageCopyFeaturesEXT& operator=(const PhysicalDeviceHostImageCopyFeaturesEXT& copy_src);
+    PhysicalDeviceHostImageCopyFeaturesEXT();
+    ~PhysicalDeviceHostImageCopyFeaturesEXT();
+    void initialize(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceHostImageCopyFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceHostImageCopyFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(this); }
+    VkPhysicalDeviceHostImageCopyFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceHostImageCopyPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t copySrcLayoutCount;
+    VkImageLayout* pCopySrcLayouts{};
+    uint32_t copyDstLayoutCount;
+    VkImageLayout* pCopyDstLayouts{};
+    uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
+    VkBool32 identicalMemoryTypeRequirements;
+
+    PhysicalDeviceHostImageCopyPropertiesEXT(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceHostImageCopyPropertiesEXT(const PhysicalDeviceHostImageCopyPropertiesEXT& copy_src);
+    PhysicalDeviceHostImageCopyPropertiesEXT& operator=(const PhysicalDeviceHostImageCopyPropertiesEXT& copy_src);
+    PhysicalDeviceHostImageCopyPropertiesEXT();
+    ~PhysicalDeviceHostImageCopyPropertiesEXT();
+    void initialize(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceHostImageCopyPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceHostImageCopyPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceHostImageCopyPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT const*>(this);
+    }
+};
+struct MemoryToImageCopyEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    const void* pHostPointer{};
+    uint32_t memoryRowLength;
+    uint32_t memoryImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+
+    MemoryToImageCopyEXT(const VkMemoryToImageCopyEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryToImageCopyEXT(const MemoryToImageCopyEXT& copy_src);
+    MemoryToImageCopyEXT& operator=(const MemoryToImageCopyEXT& copy_src);
+    MemoryToImageCopyEXT();
+    ~MemoryToImageCopyEXT();
+    void initialize(const VkMemoryToImageCopyEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryToImageCopyEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryToImageCopyEXT* ptr() { return reinterpret_cast<VkMemoryToImageCopyEXT*>(this); }
+    VkMemoryToImageCopyEXT const* ptr() const { return reinterpret_cast<VkMemoryToImageCopyEXT const*>(this); }
+};
+struct ImageToMemoryCopyEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    void* pHostPointer{};
+    uint32_t memoryRowLength;
+    uint32_t memoryImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+
+    ImageToMemoryCopyEXT(const VkImageToMemoryCopyEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImageToMemoryCopyEXT(const ImageToMemoryCopyEXT& copy_src);
+    ImageToMemoryCopyEXT& operator=(const ImageToMemoryCopyEXT& copy_src);
+    ImageToMemoryCopyEXT();
+    ~ImageToMemoryCopyEXT();
+    void initialize(const VkImageToMemoryCopyEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageToMemoryCopyEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageToMemoryCopyEXT* ptr() { return reinterpret_cast<VkImageToMemoryCopyEXT*>(this); }
+    VkImageToMemoryCopyEXT const* ptr() const { return reinterpret_cast<VkImageToMemoryCopyEXT const*>(this); }
+};
+struct CopyMemoryToImageInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkHostImageCopyFlagsEXT flags;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    MemoryToImageCopyEXT* pRegions{};
+
+    CopyMemoryToImageInfoEXT(const VkCopyMemoryToImageInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CopyMemoryToImageInfoEXT(const CopyMemoryToImageInfoEXT& copy_src);
+    CopyMemoryToImageInfoEXT& operator=(const CopyMemoryToImageInfoEXT& copy_src);
+    CopyMemoryToImageInfoEXT();
+    ~CopyMemoryToImageInfoEXT();
+    void initialize(const VkCopyMemoryToImageInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyMemoryToImageInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyMemoryToImageInfoEXT* ptr() { return reinterpret_cast<VkCopyMemoryToImageInfoEXT*>(this); }
+    VkCopyMemoryToImageInfoEXT const* ptr() const { return reinterpret_cast<VkCopyMemoryToImageInfoEXT const*>(this); }
+};
+struct CopyImageToMemoryInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkHostImageCopyFlagsEXT flags;
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    uint32_t regionCount;
+    ImageToMemoryCopyEXT* pRegions{};
+
+    CopyImageToMemoryInfoEXT(const VkCopyImageToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CopyImageToMemoryInfoEXT(const CopyImageToMemoryInfoEXT& copy_src);
+    CopyImageToMemoryInfoEXT& operator=(const CopyImageToMemoryInfoEXT& copy_src);
+    CopyImageToMemoryInfoEXT();
+    ~CopyImageToMemoryInfoEXT();
+    void initialize(const VkCopyImageToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyImageToMemoryInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyImageToMemoryInfoEXT* ptr() { return reinterpret_cast<VkCopyImageToMemoryInfoEXT*>(this); }
+    VkCopyImageToMemoryInfoEXT const* ptr() const { return reinterpret_cast<VkCopyImageToMemoryInfoEXT const*>(this); }
+};
+struct CopyImageToImageInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkHostImageCopyFlagsEXT flags;
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    ImageCopy2* pRegions{};
+
+    CopyImageToImageInfoEXT(const VkCopyImageToImageInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CopyImageToImageInfoEXT(const CopyImageToImageInfoEXT& copy_src);
+    CopyImageToImageInfoEXT& operator=(const CopyImageToImageInfoEXT& copy_src);
+    CopyImageToImageInfoEXT();
+    ~CopyImageToImageInfoEXT();
+    void initialize(const VkCopyImageToImageInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyImageToImageInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyImageToImageInfoEXT* ptr() { return reinterpret_cast<VkCopyImageToImageInfoEXT*>(this); }
+    VkCopyImageToImageInfoEXT const* ptr() const { return reinterpret_cast<VkCopyImageToImageInfoEXT const*>(this); }
+};
+struct HostImageLayoutTransitionInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    VkImageLayout oldLayout;
+    VkImageLayout newLayout;
+    VkImageSubresourceRange subresourceRange;
+
+    HostImageLayoutTransitionInfoEXT(const VkHostImageLayoutTransitionInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    HostImageLayoutTransitionInfoEXT(const HostImageLayoutTransitionInfoEXT& copy_src);
+    HostImageLayoutTransitionInfoEXT& operator=(const HostImageLayoutTransitionInfoEXT& copy_src);
+    HostImageLayoutTransitionInfoEXT();
+    ~HostImageLayoutTransitionInfoEXT();
+    void initialize(const VkHostImageLayoutTransitionInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const HostImageLayoutTransitionInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkHostImageLayoutTransitionInfoEXT* ptr() { return reinterpret_cast<VkHostImageLayoutTransitionInfoEXT*>(this); }
+    VkHostImageLayoutTransitionInfoEXT const* ptr() const {
+        return reinterpret_cast<VkHostImageLayoutTransitionInfoEXT const*>(this);
+    }
+};
+struct SubresourceHostMemcpySizeEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize size;
+
+    SubresourceHostMemcpySizeEXT(const VkSubresourceHostMemcpySizeEXT* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    SubresourceHostMemcpySizeEXT(const SubresourceHostMemcpySizeEXT& copy_src);
+    SubresourceHostMemcpySizeEXT& operator=(const SubresourceHostMemcpySizeEXT& copy_src);
+    SubresourceHostMemcpySizeEXT();
+    ~SubresourceHostMemcpySizeEXT();
+    void initialize(const VkSubresourceHostMemcpySizeEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubresourceHostMemcpySizeEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSubresourceHostMemcpySizeEXT* ptr() { return reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(this); }
+    VkSubresourceHostMemcpySizeEXT const* ptr() const { return reinterpret_cast<VkSubresourceHostMemcpySizeEXT const*>(this); }
+};
+struct HostImageCopyDevicePerformanceQueryEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 optimalDeviceAccess;
+    VkBool32 identicalMemoryLayout;
+
+    HostImageCopyDevicePerformanceQueryEXT(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    HostImageCopyDevicePerformanceQueryEXT(const HostImageCopyDevicePerformanceQueryEXT& copy_src);
+    HostImageCopyDevicePerformanceQueryEXT& operator=(const HostImageCopyDevicePerformanceQueryEXT& copy_src);
+    HostImageCopyDevicePerformanceQueryEXT();
+    ~HostImageCopyDevicePerformanceQueryEXT();
+    void initialize(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const HostImageCopyDevicePerformanceQueryEXT* copy_src, PNextCopyState* copy_state = {});
+    VkHostImageCopyDevicePerformanceQueryEXT* ptr() { return reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(this); }
+    VkHostImageCopyDevicePerformanceQueryEXT const* ptr() const {
+        return reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT const*>(this);
+    }
+};
+struct PhysicalDeviceMapMemoryPlacedFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 memoryMapPlaced;
+    VkBool32 memoryMapRangePlaced;
+    VkBool32 memoryUnmapReserve;
+
+    PhysicalDeviceMapMemoryPlacedFeaturesEXT(const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMapMemoryPlacedFeaturesEXT(const PhysicalDeviceMapMemoryPlacedFeaturesEXT& copy_src);
+    PhysicalDeviceMapMemoryPlacedFeaturesEXT& operator=(const PhysicalDeviceMapMemoryPlacedFeaturesEXT& copy_src);
+    PhysicalDeviceMapMemoryPlacedFeaturesEXT();
+    ~PhysicalDeviceMapMemoryPlacedFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMapMemoryPlacedFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceMapMemoryPlacedPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize minPlacedMemoryMapAlignment;
+
+    PhysicalDeviceMapMemoryPlacedPropertiesEXT(const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMapMemoryPlacedPropertiesEXT(const PhysicalDeviceMapMemoryPlacedPropertiesEXT& copy_src);
+    PhysicalDeviceMapMemoryPlacedPropertiesEXT& operator=(const PhysicalDeviceMapMemoryPlacedPropertiesEXT& copy_src);
+    PhysicalDeviceMapMemoryPlacedPropertiesEXT();
+    ~PhysicalDeviceMapMemoryPlacedPropertiesEXT();
+    void initialize(const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMapMemoryPlacedPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMapMemoryPlacedPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const*>(this);
+    }
+};
+struct MemoryMapPlacedInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    void* pPlacedAddress{};
+
+    MemoryMapPlacedInfoEXT(const VkMemoryMapPlacedInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MemoryMapPlacedInfoEXT(const MemoryMapPlacedInfoEXT& copy_src);
+    MemoryMapPlacedInfoEXT& operator=(const MemoryMapPlacedInfoEXT& copy_src);
+    MemoryMapPlacedInfoEXT();
+    ~MemoryMapPlacedInfoEXT();
+    void initialize(const VkMemoryMapPlacedInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryMapPlacedInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryMapPlacedInfoEXT* ptr() { return reinterpret_cast<VkMemoryMapPlacedInfoEXT*>(this); }
+    VkMemoryMapPlacedInfoEXT const* ptr() const { return reinterpret_cast<VkMemoryMapPlacedInfoEXT const*>(this); }
+};
+struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
+    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;
+
+    PhysicalDeviceShaderAtomicFloat2FeaturesEXT(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderAtomicFloat2FeaturesEXT(const PhysicalDeviceShaderAtomicFloat2FeaturesEXT& copy_src);
+    PhysicalDeviceShaderAtomicFloat2FeaturesEXT& operator=(const PhysicalDeviceShaderAtomicFloat2FeaturesEXT& copy_src);
+    PhysicalDeviceShaderAtomicFloat2FeaturesEXT();
+    ~PhysicalDeviceShaderAtomicFloat2FeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderAtomicFloat2FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const*>(this);
+    }
+};
+struct SurfacePresentModeEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkPresentModeKHR presentMode;
+
+    SurfacePresentModeEXT(const VkSurfacePresentModeEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SurfacePresentModeEXT(const SurfacePresentModeEXT& copy_src);
+    SurfacePresentModeEXT& operator=(const SurfacePresentModeEXT& copy_src);
+    SurfacePresentModeEXT();
+    ~SurfacePresentModeEXT();
+    void initialize(const VkSurfacePresentModeEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SurfacePresentModeEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfacePresentModeEXT* ptr() { return reinterpret_cast<VkSurfacePresentModeEXT*>(this); }
+    VkSurfacePresentModeEXT const* ptr() const { return reinterpret_cast<VkSurfacePresentModeEXT const*>(this); }
+};
+struct SurfacePresentScalingCapabilitiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkPresentScalingFlagsEXT supportedPresentScaling;
+    VkPresentGravityFlagsEXT supportedPresentGravityX;
+    VkPresentGravityFlagsEXT supportedPresentGravityY;
+    VkExtent2D minScaledImageExtent;
+    VkExtent2D maxScaledImageExtent;
+
+    SurfacePresentScalingCapabilitiesEXT(const VkSurfacePresentScalingCapabilitiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    SurfacePresentScalingCapabilitiesEXT(const SurfacePresentScalingCapabilitiesEXT& copy_src);
+    SurfacePresentScalingCapabilitiesEXT& operator=(const SurfacePresentScalingCapabilitiesEXT& copy_src);
+    SurfacePresentScalingCapabilitiesEXT();
+    ~SurfacePresentScalingCapabilitiesEXT();
+    void initialize(const VkSurfacePresentScalingCapabilitiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SurfacePresentScalingCapabilitiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfacePresentScalingCapabilitiesEXT* ptr() { return reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(this); }
+    VkSurfacePresentScalingCapabilitiesEXT const* ptr() const {
+        return reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT const*>(this);
+    }
+};
+struct SurfacePresentModeCompatibilityEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t presentModeCount;
+    VkPresentModeKHR* pPresentModes{};
+
+    SurfacePresentModeCompatibilityEXT(const VkSurfacePresentModeCompatibilityEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    SurfacePresentModeCompatibilityEXT(const SurfacePresentModeCompatibilityEXT& copy_src);
+    SurfacePresentModeCompatibilityEXT& operator=(const SurfacePresentModeCompatibilityEXT& copy_src);
+    SurfacePresentModeCompatibilityEXT();
+    ~SurfacePresentModeCompatibilityEXT();
+    void initialize(const VkSurfacePresentModeCompatibilityEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SurfacePresentModeCompatibilityEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfacePresentModeCompatibilityEXT* ptr() { return reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(this); }
+    VkSurfacePresentModeCompatibilityEXT const* ptr() const {
+        return reinterpret_cast<VkSurfacePresentModeCompatibilityEXT const*>(this);
+    }
+};
+struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 swapchainMaintenance1;
+
+    PhysicalDeviceSwapchainMaintenance1FeaturesEXT(const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSwapchainMaintenance1FeaturesEXT(const PhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src);
+    PhysicalDeviceSwapchainMaintenance1FeaturesEXT& operator=(const PhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src);
+    PhysicalDeviceSwapchainMaintenance1FeaturesEXT();
+    ~PhysicalDeviceSwapchainMaintenance1FeaturesEXT();
+    void initialize(const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSwapchainMaintenance1FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT const*>(this);
+    }
+};
+struct SwapchainPresentFenceInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    VkFence* pFences{};
+
+    SwapchainPresentFenceInfoEXT(const VkSwapchainPresentFenceInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    SwapchainPresentFenceInfoEXT(const SwapchainPresentFenceInfoEXT& copy_src);
+    SwapchainPresentFenceInfoEXT& operator=(const SwapchainPresentFenceInfoEXT& copy_src);
+    SwapchainPresentFenceInfoEXT();
+    ~SwapchainPresentFenceInfoEXT();
+    void initialize(const VkSwapchainPresentFenceInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SwapchainPresentFenceInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainPresentFenceInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentFenceInfoEXT*>(this); }
+    VkSwapchainPresentFenceInfoEXT const* ptr() const { return reinterpret_cast<VkSwapchainPresentFenceInfoEXT const*>(this); }
+};
+struct SwapchainPresentModesCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t presentModeCount;
+    const VkPresentModeKHR* pPresentModes{};
+
+    SwapchainPresentModesCreateInfoEXT(const VkSwapchainPresentModesCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    SwapchainPresentModesCreateInfoEXT(const SwapchainPresentModesCreateInfoEXT& copy_src);
+    SwapchainPresentModesCreateInfoEXT& operator=(const SwapchainPresentModesCreateInfoEXT& copy_src);
+    SwapchainPresentModesCreateInfoEXT();
+    ~SwapchainPresentModesCreateInfoEXT();
+    void initialize(const VkSwapchainPresentModesCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SwapchainPresentModesCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainPresentModesCreateInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT*>(this); }
+    VkSwapchainPresentModesCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT const*>(this);
+    }
+};
+struct SwapchainPresentModeInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    const VkPresentModeKHR* pPresentModes{};
+
+    SwapchainPresentModeInfoEXT(const VkSwapchainPresentModeInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    SwapchainPresentModeInfoEXT(const SwapchainPresentModeInfoEXT& copy_src);
+    SwapchainPresentModeInfoEXT& operator=(const SwapchainPresentModeInfoEXT& copy_src);
+    SwapchainPresentModeInfoEXT();
+    ~SwapchainPresentModeInfoEXT();
+    void initialize(const VkSwapchainPresentModeInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SwapchainPresentModeInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainPresentModeInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentModeInfoEXT*>(this); }
+    VkSwapchainPresentModeInfoEXT const* ptr() const { return reinterpret_cast<VkSwapchainPresentModeInfoEXT const*>(this); }
+};
+struct SwapchainPresentScalingCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPresentScalingFlagsEXT scalingBehavior;
+    VkPresentGravityFlagsEXT presentGravityX;
+    VkPresentGravityFlagsEXT presentGravityY;
+
+    SwapchainPresentScalingCreateInfoEXT(const VkSwapchainPresentScalingCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    SwapchainPresentScalingCreateInfoEXT(const SwapchainPresentScalingCreateInfoEXT& copy_src);
+    SwapchainPresentScalingCreateInfoEXT& operator=(const SwapchainPresentScalingCreateInfoEXT& copy_src);
+    SwapchainPresentScalingCreateInfoEXT();
+    ~SwapchainPresentScalingCreateInfoEXT();
+    void initialize(const VkSwapchainPresentScalingCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SwapchainPresentScalingCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainPresentScalingCreateInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT*>(this); }
+    VkSwapchainPresentScalingCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT const*>(this);
+    }
+};
+struct ReleaseSwapchainImagesInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSwapchainKHR swapchain;
+    uint32_t imageIndexCount;
+    const uint32_t* pImageIndices{};
+
+    ReleaseSwapchainImagesInfoEXT(const VkReleaseSwapchainImagesInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    ReleaseSwapchainImagesInfoEXT(const ReleaseSwapchainImagesInfoEXT& copy_src);
+    ReleaseSwapchainImagesInfoEXT& operator=(const ReleaseSwapchainImagesInfoEXT& copy_src);
+    ReleaseSwapchainImagesInfoEXT();
+    ~ReleaseSwapchainImagesInfoEXT();
+    void initialize(const VkReleaseSwapchainImagesInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ReleaseSwapchainImagesInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkReleaseSwapchainImagesInfoEXT* ptr() { return reinterpret_cast<VkReleaseSwapchainImagesInfoEXT*>(this); }
+    VkReleaseSwapchainImagesInfoEXT const* ptr() const { return reinterpret_cast<VkReleaseSwapchainImagesInfoEXT const*>(this); }
+};
+struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
+    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;
+
+    PhysicalDeviceDeviceGeneratedCommandsPropertiesNV(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDeviceGeneratedCommandsPropertiesNV(const PhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src);
+    PhysicalDeviceDeviceGeneratedCommandsPropertiesNV& operator=(const PhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src);
+    PhysicalDeviceDeviceGeneratedCommandsPropertiesNV();
+    ~PhysicalDeviceDeviceGeneratedCommandsPropertiesNV();
+    void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDeviceGeneratedCommandsPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const*>(this);
+    }
+};
+struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 deviceGeneratedCommands;
+
+    PhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const PhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src);
+    PhysicalDeviceDeviceGeneratedCommandsFeaturesNV& operator=(const PhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src);
+    PhysicalDeviceDeviceGeneratedCommandsFeaturesNV();
+    ~PhysicalDeviceDeviceGeneratedCommandsFeaturesNV();
+    void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDeviceGeneratedCommandsFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const*>(this);
+    }
+};
+struct GraphicsShaderGroupCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stageCount;
+    PipelineShaderStageCreateInfo* pStages{};
+    PipelineVertexInputStateCreateInfo* pVertexInputState{};
+    PipelineTessellationStateCreateInfo* pTessellationState{};
+
+    GraphicsShaderGroupCreateInfoNV(const VkGraphicsShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    GraphicsShaderGroupCreateInfoNV(const GraphicsShaderGroupCreateInfoNV& copy_src);
+    GraphicsShaderGroupCreateInfoNV& operator=(const GraphicsShaderGroupCreateInfoNV& copy_src);
+    GraphicsShaderGroupCreateInfoNV();
+    ~GraphicsShaderGroupCreateInfoNV();
+    void initialize(const VkGraphicsShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const GraphicsShaderGroupCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkGraphicsShaderGroupCreateInfoNV* ptr() { return reinterpret_cast<VkGraphicsShaderGroupCreateInfoNV*>(this); }
+    VkGraphicsShaderGroupCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkGraphicsShaderGroupCreateInfoNV const*>(this);
+    }
+};
+struct GraphicsPipelineShaderGroupsCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t groupCount;
+    GraphicsShaderGroupCreateInfoNV* pGroups{};
+    uint32_t pipelineCount;
+    VkPipeline* pPipelines{};
+
+    GraphicsPipelineShaderGroupsCreateInfoNV(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    GraphicsPipelineShaderGroupsCreateInfoNV(const GraphicsPipelineShaderGroupsCreateInfoNV& copy_src);
+    GraphicsPipelineShaderGroupsCreateInfoNV& operator=(const GraphicsPipelineShaderGroupsCreateInfoNV& copy_src);
+    GraphicsPipelineShaderGroupsCreateInfoNV();
+    ~GraphicsPipelineShaderGroupsCreateInfoNV();
+    void initialize(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const GraphicsPipelineShaderGroupsCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkGraphicsPipelineShaderGroupsCreateInfoNV* ptr() {
+        return reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(this);
+    }
+    VkGraphicsPipelineShaderGroupsCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV const*>(this);
+    }
+};
+struct IndirectCommandsLayoutTokenNV {
+    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{};
+
+    IndirectCommandsLayoutTokenNV(const VkIndirectCommandsLayoutTokenNV* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    IndirectCommandsLayoutTokenNV(const IndirectCommandsLayoutTokenNV& copy_src);
+    IndirectCommandsLayoutTokenNV& operator=(const IndirectCommandsLayoutTokenNV& copy_src);
+    IndirectCommandsLayoutTokenNV();
+    ~IndirectCommandsLayoutTokenNV();
+    void initialize(const VkIndirectCommandsLayoutTokenNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const IndirectCommandsLayoutTokenNV* copy_src, PNextCopyState* copy_state = {});
+    VkIndirectCommandsLayoutTokenNV* ptr() { return reinterpret_cast<VkIndirectCommandsLayoutTokenNV*>(this); }
+    VkIndirectCommandsLayoutTokenNV const* ptr() const { return reinterpret_cast<VkIndirectCommandsLayoutTokenNV const*>(this); }
+};
+struct IndirectCommandsLayoutCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkIndirectCommandsLayoutUsageFlagsNV flags;
+    VkPipelineBindPoint pipelineBindPoint;
+    uint32_t tokenCount;
+    IndirectCommandsLayoutTokenNV* pTokens{};
+    uint32_t streamCount;
+    const uint32_t* pStreamStrides{};
+
+    IndirectCommandsLayoutCreateInfoNV(const VkIndirectCommandsLayoutCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    IndirectCommandsLayoutCreateInfoNV(const IndirectCommandsLayoutCreateInfoNV& copy_src);
+    IndirectCommandsLayoutCreateInfoNV& operator=(const IndirectCommandsLayoutCreateInfoNV& copy_src);
+    IndirectCommandsLayoutCreateInfoNV();
+    ~IndirectCommandsLayoutCreateInfoNV();
+    void initialize(const VkIndirectCommandsLayoutCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const IndirectCommandsLayoutCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkIndirectCommandsLayoutCreateInfoNV* ptr() { return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNV*>(this); }
+    VkIndirectCommandsLayoutCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNV const*>(this);
+    }
+};
+struct GeneratedCommandsInfoNV {
+    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;
+
+    GeneratedCommandsInfoNV(const VkGeneratedCommandsInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    GeneratedCommandsInfoNV(const GeneratedCommandsInfoNV& copy_src);
+    GeneratedCommandsInfoNV& operator=(const GeneratedCommandsInfoNV& copy_src);
+    GeneratedCommandsInfoNV();
+    ~GeneratedCommandsInfoNV();
+    void initialize(const VkGeneratedCommandsInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const GeneratedCommandsInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkGeneratedCommandsInfoNV* ptr() { return reinterpret_cast<VkGeneratedCommandsInfoNV*>(this); }
+    VkGeneratedCommandsInfoNV const* ptr() const { return reinterpret_cast<VkGeneratedCommandsInfoNV const*>(this); }
+};
+struct GeneratedCommandsMemoryRequirementsInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineBindPoint pipelineBindPoint;
+    VkPipeline pipeline;
+    VkIndirectCommandsLayoutNV indirectCommandsLayout;
+    uint32_t maxSequencesCount;
+
+    GeneratedCommandsMemoryRequirementsInfoNV(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    GeneratedCommandsMemoryRequirementsInfoNV(const GeneratedCommandsMemoryRequirementsInfoNV& copy_src);
+    GeneratedCommandsMemoryRequirementsInfoNV& operator=(const GeneratedCommandsMemoryRequirementsInfoNV& copy_src);
+    GeneratedCommandsMemoryRequirementsInfoNV();
+    ~GeneratedCommandsMemoryRequirementsInfoNV();
+    void initialize(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const GeneratedCommandsMemoryRequirementsInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkGeneratedCommandsMemoryRequirementsInfoNV* ptr() {
+        return reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoNV*>(this);
+    }
+    VkGeneratedCommandsMemoryRequirementsInfoNV const* ptr() const {
+        return reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceInheritedViewportScissorFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 inheritedViewportScissor2D;
+
+    PhysicalDeviceInheritedViewportScissorFeaturesNV(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceInheritedViewportScissorFeaturesNV(const PhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src);
+    PhysicalDeviceInheritedViewportScissorFeaturesNV& operator=(const PhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src);
+    PhysicalDeviceInheritedViewportScissorFeaturesNV();
+    ~PhysicalDeviceInheritedViewportScissorFeaturesNV();
+    void initialize(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceInheritedViewportScissorFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceInheritedViewportScissorFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceInheritedViewportScissorFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV const*>(this);
+    }
+};
+struct CommandBufferInheritanceViewportScissorInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 viewportScissor2D;
+    uint32_t viewportDepthCount;
+    const VkViewport* pViewportDepths{};
+
+    CommandBufferInheritanceViewportScissorInfoNV(const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CommandBufferInheritanceViewportScissorInfoNV(const CommandBufferInheritanceViewportScissorInfoNV& copy_src);
+    CommandBufferInheritanceViewportScissorInfoNV& operator=(const CommandBufferInheritanceViewportScissorInfoNV& copy_src);
+    CommandBufferInheritanceViewportScissorInfoNV();
+    ~CommandBufferInheritanceViewportScissorInfoNV();
+    void initialize(const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CommandBufferInheritanceViewportScissorInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferInheritanceViewportScissorInfoNV* ptr() {
+        return reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(this);
+    }
+    VkCommandBufferInheritanceViewportScissorInfoNV const* ptr() const {
+        return reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 texelBufferAlignment;
+
+    PhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceTexelBufferAlignmentFeaturesEXT(const PhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src);
+    PhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=(const PhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src);
+    PhysicalDeviceTexelBufferAlignmentFeaturesEXT();
+    ~PhysicalDeviceTexelBufferAlignmentFeaturesEXT();
+    void initialize(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceTexelBufferAlignmentFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const*>(this);
+    }
+};
+struct RenderPassTransformBeginInfoQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkSurfaceTransformFlagBitsKHR transform;
+
+    RenderPassTransformBeginInfoQCOM(const VkRenderPassTransformBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    RenderPassTransformBeginInfoQCOM(const RenderPassTransformBeginInfoQCOM& copy_src);
+    RenderPassTransformBeginInfoQCOM& operator=(const RenderPassTransformBeginInfoQCOM& copy_src);
+    RenderPassTransformBeginInfoQCOM();
+    ~RenderPassTransformBeginInfoQCOM();
+    void initialize(const VkRenderPassTransformBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassTransformBeginInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassTransformBeginInfoQCOM* ptr() { return reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(this); }
+    VkRenderPassTransformBeginInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkRenderPassTransformBeginInfoQCOM const*>(this);
+    }
+};
+struct CommandBufferInheritanceRenderPassTransformInfoQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkSurfaceTransformFlagBitsKHR transform;
+    VkRect2D renderArea;
+
+    CommandBufferInheritanceRenderPassTransformInfoQCOM(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CommandBufferInheritanceRenderPassTransformInfoQCOM(const CommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src);
+    CommandBufferInheritanceRenderPassTransformInfoQCOM& operator=(
+        const CommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src);
+    CommandBufferInheritanceRenderPassTransformInfoQCOM();
+    ~CommandBufferInheritanceRenderPassTransformInfoQCOM();
+    void initialize(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CommandBufferInheritanceRenderPassTransformInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferInheritanceRenderPassTransformInfoQCOM* ptr() {
+        return reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(this);
+    }
+    VkCommandBufferInheritanceRenderPassTransformInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM const*>(this);
+    }
+};
+struct PhysicalDeviceDepthBiasControlFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 depthBiasControl;
+    VkBool32 leastRepresentableValueForceUnormRepresentation;
+    VkBool32 floatRepresentation;
+    VkBool32 depthBiasExact;
+
+    PhysicalDeviceDepthBiasControlFeaturesEXT(const VkPhysicalDeviceDepthBiasControlFeaturesEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDepthBiasControlFeaturesEXT(const PhysicalDeviceDepthBiasControlFeaturesEXT& copy_src);
+    PhysicalDeviceDepthBiasControlFeaturesEXT& operator=(const PhysicalDeviceDepthBiasControlFeaturesEXT& copy_src);
+    PhysicalDeviceDepthBiasControlFeaturesEXT();
+    ~PhysicalDeviceDepthBiasControlFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDepthBiasControlFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDepthBiasControlFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthBiasControlFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDepthBiasControlFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT const*>(this);
+    }
+};
+struct DepthBiasInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    float depthBiasConstantFactor;
+    float depthBiasClamp;
+    float depthBiasSlopeFactor;
+
+    DepthBiasInfoEXT(const VkDepthBiasInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DepthBiasInfoEXT(const DepthBiasInfoEXT& copy_src);
+    DepthBiasInfoEXT& operator=(const DepthBiasInfoEXT& copy_src);
+    DepthBiasInfoEXT();
+    ~DepthBiasInfoEXT();
+    void initialize(const VkDepthBiasInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DepthBiasInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDepthBiasInfoEXT* ptr() { return reinterpret_cast<VkDepthBiasInfoEXT*>(this); }
+    VkDepthBiasInfoEXT const* ptr() const { return reinterpret_cast<VkDepthBiasInfoEXT const*>(this); }
+};
+struct DepthBiasRepresentationInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDepthBiasRepresentationEXT depthBiasRepresentation;
+    VkBool32 depthBiasExact;
+
+    DepthBiasRepresentationInfoEXT(const VkDepthBiasRepresentationInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    DepthBiasRepresentationInfoEXT(const DepthBiasRepresentationInfoEXT& copy_src);
+    DepthBiasRepresentationInfoEXT& operator=(const DepthBiasRepresentationInfoEXT& copy_src);
+    DepthBiasRepresentationInfoEXT();
+    ~DepthBiasRepresentationInfoEXT();
+    void initialize(const VkDepthBiasRepresentationInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DepthBiasRepresentationInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDepthBiasRepresentationInfoEXT* ptr() { return reinterpret_cast<VkDepthBiasRepresentationInfoEXT*>(this); }
+    VkDepthBiasRepresentationInfoEXT const* ptr() const { return reinterpret_cast<VkDepthBiasRepresentationInfoEXT const*>(this); }
+};
+struct PhysicalDeviceDeviceMemoryReportFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 deviceMemoryReport;
+
+    PhysicalDeviceDeviceMemoryReportFeaturesEXT(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDeviceMemoryReportFeaturesEXT(const PhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src);
+    PhysicalDeviceDeviceMemoryReportFeaturesEXT& operator=(const PhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src);
+    PhysicalDeviceDeviceMemoryReportFeaturesEXT();
+    ~PhysicalDeviceDeviceMemoryReportFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDeviceMemoryReportFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const*>(this);
+    }
+};
+struct DeviceMemoryReportCallbackDataEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceMemoryReportFlagsEXT flags;
+    VkDeviceMemoryReportEventTypeEXT type;
+    uint64_t memoryObjectId;
+    VkDeviceSize size;
+    VkObjectType objectType;
+    uint64_t objectHandle;
+    uint32_t heapIndex;
+
+    DeviceMemoryReportCallbackDataEXT(const VkDeviceMemoryReportCallbackDataEXT* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    DeviceMemoryReportCallbackDataEXT(const DeviceMemoryReportCallbackDataEXT& copy_src);
+    DeviceMemoryReportCallbackDataEXT& operator=(const DeviceMemoryReportCallbackDataEXT& copy_src);
+    DeviceMemoryReportCallbackDataEXT();
+    ~DeviceMemoryReportCallbackDataEXT();
+    void initialize(const VkDeviceMemoryReportCallbackDataEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceMemoryReportCallbackDataEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceMemoryReportCallbackDataEXT* ptr() { return reinterpret_cast<VkDeviceMemoryReportCallbackDataEXT*>(this); }
+    VkDeviceMemoryReportCallbackDataEXT const* ptr() const {
+        return reinterpret_cast<VkDeviceMemoryReportCallbackDataEXT const*>(this);
+    }
+};
+struct DeviceDeviceMemoryReportCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemoryReportFlagsEXT flags;
+    PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback;
+    void* pUserData{};
+
+    DeviceDeviceMemoryReportCreateInfoEXT(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    DeviceDeviceMemoryReportCreateInfoEXT(const DeviceDeviceMemoryReportCreateInfoEXT& copy_src);
+    DeviceDeviceMemoryReportCreateInfoEXT& operator=(const DeviceDeviceMemoryReportCreateInfoEXT& copy_src);
+    DeviceDeviceMemoryReportCreateInfoEXT();
+    ~DeviceDeviceMemoryReportCreateInfoEXT();
+    void initialize(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceDeviceMemoryReportCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceDeviceMemoryReportCreateInfoEXT* ptr() { return reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(this); }
+    VkDeviceDeviceMemoryReportCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT const*>(this);
+    }
+};
+struct PhysicalDeviceRobustness2FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 robustBufferAccess2;
+    VkBool32 robustImageAccess2;
+    VkBool32 nullDescriptor;
+
+    PhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDeviceRobustness2FeaturesEXT(const PhysicalDeviceRobustness2FeaturesEXT& copy_src);
+    PhysicalDeviceRobustness2FeaturesEXT& operator=(const PhysicalDeviceRobustness2FeaturesEXT& copy_src);
+    PhysicalDeviceRobustness2FeaturesEXT();
+    ~PhysicalDeviceRobustness2FeaturesEXT();
+    void initialize(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRobustness2FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRobustness2FeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(this); }
+    VkPhysicalDeviceRobustness2FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceRobustness2PropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize robustStorageBufferAccessSizeAlignment;
+    VkDeviceSize robustUniformBufferAccessSizeAlignment;
+
+    PhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRobustness2PropertiesEXT(const PhysicalDeviceRobustness2PropertiesEXT& copy_src);
+    PhysicalDeviceRobustness2PropertiesEXT& operator=(const PhysicalDeviceRobustness2PropertiesEXT& copy_src);
+    PhysicalDeviceRobustness2PropertiesEXT();
+    ~PhysicalDeviceRobustness2PropertiesEXT();
+    void initialize(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRobustness2PropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRobustness2PropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(this); }
+    VkPhysicalDeviceRobustness2PropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT const*>(this);
+    }
+};
+struct SamplerCustomBorderColorCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkClearColorValue customBorderColor;
+    VkFormat format;
+
+    SamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    SamplerCustomBorderColorCreateInfoEXT(const SamplerCustomBorderColorCreateInfoEXT& copy_src);
+    SamplerCustomBorderColorCreateInfoEXT& operator=(const SamplerCustomBorderColorCreateInfoEXT& copy_src);
+    SamplerCustomBorderColorCreateInfoEXT();
+    ~SamplerCustomBorderColorCreateInfoEXT();
+    void initialize(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SamplerCustomBorderColorCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerCustomBorderColorCreateInfoEXT* ptr() { return reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(this); }
+    VkSamplerCustomBorderColorCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT const*>(this);
+    }
+};
+struct PhysicalDeviceCustomBorderColorPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxCustomBorderColorSamplers;
+
+    PhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCustomBorderColorPropertiesEXT(const PhysicalDeviceCustomBorderColorPropertiesEXT& copy_src);
+    PhysicalDeviceCustomBorderColorPropertiesEXT& operator=(const PhysicalDeviceCustomBorderColorPropertiesEXT& copy_src);
+    PhysicalDeviceCustomBorderColorPropertiesEXT();
+    ~PhysicalDeviceCustomBorderColorPropertiesEXT();
+    void initialize(const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCustomBorderColorPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCustomBorderColorPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceCustomBorderColorPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceCustomBorderColorFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 customBorderColors;
+    VkBool32 customBorderColorWithoutFormat;
+
+    PhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCustomBorderColorFeaturesEXT(const PhysicalDeviceCustomBorderColorFeaturesEXT& copy_src);
+    PhysicalDeviceCustomBorderColorFeaturesEXT& operator=(const PhysicalDeviceCustomBorderColorFeaturesEXT& copy_src);
+    PhysicalDeviceCustomBorderColorFeaturesEXT();
+    ~PhysicalDeviceCustomBorderColorFeaturesEXT();
+    void initialize(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCustomBorderColorFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCustomBorderColorFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceCustomBorderColorFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDevicePresentBarrierFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentBarrier;
+
+    PhysicalDevicePresentBarrierFeaturesNV(const VkPhysicalDevicePresentBarrierFeaturesNV* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePresentBarrierFeaturesNV(const PhysicalDevicePresentBarrierFeaturesNV& copy_src);
+    PhysicalDevicePresentBarrierFeaturesNV& operator=(const PhysicalDevicePresentBarrierFeaturesNV& copy_src);
+    PhysicalDevicePresentBarrierFeaturesNV();
+    ~PhysicalDevicePresentBarrierFeaturesNV();
+    void initialize(const VkPhysicalDevicePresentBarrierFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePresentBarrierFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePresentBarrierFeaturesNV* ptr() { return reinterpret_cast<VkPhysicalDevicePresentBarrierFeaturesNV*>(this); }
+    VkPhysicalDevicePresentBarrierFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePresentBarrierFeaturesNV const*>(this);
+    }
+};
+struct SurfaceCapabilitiesPresentBarrierNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentBarrierSupported;
+
+    SurfaceCapabilitiesPresentBarrierNV(const VkSurfaceCapabilitiesPresentBarrierNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    SurfaceCapabilitiesPresentBarrierNV(const SurfaceCapabilitiesPresentBarrierNV& copy_src);
+    SurfaceCapabilitiesPresentBarrierNV& operator=(const SurfaceCapabilitiesPresentBarrierNV& copy_src);
+    SurfaceCapabilitiesPresentBarrierNV();
+    ~SurfaceCapabilitiesPresentBarrierNV();
+    void initialize(const VkSurfaceCapabilitiesPresentBarrierNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SurfaceCapabilitiesPresentBarrierNV* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceCapabilitiesPresentBarrierNV* ptr() { return reinterpret_cast<VkSurfaceCapabilitiesPresentBarrierNV*>(this); }
+    VkSurfaceCapabilitiesPresentBarrierNV const* ptr() const {
+        return reinterpret_cast<VkSurfaceCapabilitiesPresentBarrierNV const*>(this);
+    }
+};
+struct SwapchainPresentBarrierCreateInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentBarrierEnable;
+
+    SwapchainPresentBarrierCreateInfoNV(const VkSwapchainPresentBarrierCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    SwapchainPresentBarrierCreateInfoNV(const SwapchainPresentBarrierCreateInfoNV& copy_src);
+    SwapchainPresentBarrierCreateInfoNV& operator=(const SwapchainPresentBarrierCreateInfoNV& copy_src);
+    SwapchainPresentBarrierCreateInfoNV();
+    ~SwapchainPresentBarrierCreateInfoNV();
+    void initialize(const VkSwapchainPresentBarrierCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SwapchainPresentBarrierCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainPresentBarrierCreateInfoNV* ptr() { return reinterpret_cast<VkSwapchainPresentBarrierCreateInfoNV*>(this); }
+    VkSwapchainPresentBarrierCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkSwapchainPresentBarrierCreateInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceDiagnosticsConfigFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 diagnosticsConfig;
+
+    PhysicalDeviceDiagnosticsConfigFeaturesNV(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDiagnosticsConfigFeaturesNV(const PhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src);
+    PhysicalDeviceDiagnosticsConfigFeaturesNV& operator=(const PhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src);
+    PhysicalDeviceDiagnosticsConfigFeaturesNV();
+    ~PhysicalDeviceDiagnosticsConfigFeaturesNV();
+    void initialize(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDiagnosticsConfigFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDiagnosticsConfigFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV const*>(this);
+    }
+};
+struct DeviceDiagnosticsConfigCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceDiagnosticsConfigFlagsNV flags;
+
+    DeviceDiagnosticsConfigCreateInfoNV(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    DeviceDiagnosticsConfigCreateInfoNV(const DeviceDiagnosticsConfigCreateInfoNV& copy_src);
+    DeviceDiagnosticsConfigCreateInfoNV& operator=(const DeviceDiagnosticsConfigCreateInfoNV& copy_src);
+    DeviceDiagnosticsConfigCreateInfoNV();
+    ~DeviceDiagnosticsConfigCreateInfoNV();
+    void initialize(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceDiagnosticsConfigCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceDiagnosticsConfigCreateInfoNV* ptr() { return reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(this); }
+    VkDeviceDiagnosticsConfigCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV const*>(this);
+    }
+};
+struct CudaModuleCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    size_t dataSize;
+    const void* pData{};
+
+    CudaModuleCreateInfoNV(const VkCudaModuleCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CudaModuleCreateInfoNV(const CudaModuleCreateInfoNV& copy_src);
+    CudaModuleCreateInfoNV& operator=(const CudaModuleCreateInfoNV& copy_src);
+    CudaModuleCreateInfoNV();
+    ~CudaModuleCreateInfoNV();
+    void initialize(const VkCudaModuleCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CudaModuleCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkCudaModuleCreateInfoNV* ptr() { return reinterpret_cast<VkCudaModuleCreateInfoNV*>(this); }
+    VkCudaModuleCreateInfoNV const* ptr() const { return reinterpret_cast<VkCudaModuleCreateInfoNV const*>(this); }
+};
+struct CudaFunctionCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCudaModuleNV module;
+    const char* pName{};
+
+    CudaFunctionCreateInfoNV(const VkCudaFunctionCreateInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CudaFunctionCreateInfoNV(const CudaFunctionCreateInfoNV& copy_src);
+    CudaFunctionCreateInfoNV& operator=(const CudaFunctionCreateInfoNV& copy_src);
+    CudaFunctionCreateInfoNV();
+    ~CudaFunctionCreateInfoNV();
+    void initialize(const VkCudaFunctionCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CudaFunctionCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkCudaFunctionCreateInfoNV* ptr() { return reinterpret_cast<VkCudaFunctionCreateInfoNV*>(this); }
+    VkCudaFunctionCreateInfoNV const* ptr() const { return reinterpret_cast<VkCudaFunctionCreateInfoNV const*>(this); }
+};
+struct CudaLaunchInfoNV {
+    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{};
+
+    CudaLaunchInfoNV(const VkCudaLaunchInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CudaLaunchInfoNV(const CudaLaunchInfoNV& copy_src);
+    CudaLaunchInfoNV& operator=(const CudaLaunchInfoNV& copy_src);
+    CudaLaunchInfoNV();
+    ~CudaLaunchInfoNV();
+    void initialize(const VkCudaLaunchInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CudaLaunchInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkCudaLaunchInfoNV* ptr() { return reinterpret_cast<VkCudaLaunchInfoNV*>(this); }
+    VkCudaLaunchInfoNV const* ptr() const { return reinterpret_cast<VkCudaLaunchInfoNV const*>(this); }
+};
+struct PhysicalDeviceCudaKernelLaunchFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cudaKernelLaunchFeatures;
+
+    PhysicalDeviceCudaKernelLaunchFeaturesNV(const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCudaKernelLaunchFeaturesNV(const PhysicalDeviceCudaKernelLaunchFeaturesNV& copy_src);
+    PhysicalDeviceCudaKernelLaunchFeaturesNV& operator=(const PhysicalDeviceCudaKernelLaunchFeaturesNV& copy_src);
+    PhysicalDeviceCudaKernelLaunchFeaturesNV();
+    ~PhysicalDeviceCudaKernelLaunchFeaturesNV();
+    void initialize(const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCudaKernelLaunchFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCudaKernelLaunchFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCudaKernelLaunchFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCudaKernelLaunchFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceCudaKernelLaunchPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t computeCapabilityMinor;
+    uint32_t computeCapabilityMajor;
+
+    PhysicalDeviceCudaKernelLaunchPropertiesNV(const VkPhysicalDeviceCudaKernelLaunchPropertiesNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCudaKernelLaunchPropertiesNV(const PhysicalDeviceCudaKernelLaunchPropertiesNV& copy_src);
+    PhysicalDeviceCudaKernelLaunchPropertiesNV& operator=(const PhysicalDeviceCudaKernelLaunchPropertiesNV& copy_src);
+    PhysicalDeviceCudaKernelLaunchPropertiesNV();
+    ~PhysicalDeviceCudaKernelLaunchPropertiesNV();
+    void initialize(const VkPhysicalDeviceCudaKernelLaunchPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCudaKernelLaunchPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCudaKernelLaunchPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCudaKernelLaunchPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceCudaKernelLaunchPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCudaKernelLaunchPropertiesNV const*>(this);
+    }
+};
+struct QueryLowLatencySupportNV {
+    VkStructureType sType;
+    const void* pNext{};
+    void* pQueriedLowLatencyData{};
+
+    QueryLowLatencySupportNV(const VkQueryLowLatencySupportNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    QueryLowLatencySupportNV(const QueryLowLatencySupportNV& copy_src);
+    QueryLowLatencySupportNV& operator=(const QueryLowLatencySupportNV& copy_src);
+    QueryLowLatencySupportNV();
+    ~QueryLowLatencySupportNV();
+    void initialize(const VkQueryLowLatencySupportNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const QueryLowLatencySupportNV* 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 ExportMetalObjectCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExportMetalObjectTypeFlagBitsEXT exportObjectType;
+
+    ExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    ExportMetalObjectCreateInfoEXT(const ExportMetalObjectCreateInfoEXT& copy_src);
+    ExportMetalObjectCreateInfoEXT& operator=(const ExportMetalObjectCreateInfoEXT& copy_src);
+    ExportMetalObjectCreateInfoEXT();
+    ~ExportMetalObjectCreateInfoEXT();
+    void initialize(const VkExportMetalObjectCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMetalObjectCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalObjectCreateInfoEXT* ptr() { return reinterpret_cast<VkExportMetalObjectCreateInfoEXT*>(this); }
+    VkExportMetalObjectCreateInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalObjectCreateInfoEXT const*>(this); }
+};
+struct ExportMetalObjectsInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+
+    ExportMetalObjectsInfoEXT(const VkExportMetalObjectsInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    ExportMetalObjectsInfoEXT(const ExportMetalObjectsInfoEXT& copy_src);
+    ExportMetalObjectsInfoEXT& operator=(const ExportMetalObjectsInfoEXT& copy_src);
+    ExportMetalObjectsInfoEXT();
+    ~ExportMetalObjectsInfoEXT();
+    void initialize(const VkExportMetalObjectsInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMetalObjectsInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalObjectsInfoEXT* ptr() { return reinterpret_cast<VkExportMetalObjectsInfoEXT*>(this); }
+    VkExportMetalObjectsInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalObjectsInfoEXT const*>(this); }
+};
+struct ExportMetalDeviceInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    MTLDevice_id mtlDevice;
+
+    ExportMetalDeviceInfoEXT(const VkExportMetalDeviceInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ExportMetalDeviceInfoEXT(const ExportMetalDeviceInfoEXT& copy_src);
+    ExportMetalDeviceInfoEXT& operator=(const ExportMetalDeviceInfoEXT& copy_src);
+    ExportMetalDeviceInfoEXT();
+    ~ExportMetalDeviceInfoEXT();
+    void initialize(const VkExportMetalDeviceInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMetalDeviceInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalDeviceInfoEXT* ptr() { return reinterpret_cast<VkExportMetalDeviceInfoEXT*>(this); }
+    VkExportMetalDeviceInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalDeviceInfoEXT const*>(this); }
+};
+struct ExportMetalCommandQueueInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueue queue;
+    MTLCommandQueue_id mtlCommandQueue;
+
+    ExportMetalCommandQueueInfoEXT(const VkExportMetalCommandQueueInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    ExportMetalCommandQueueInfoEXT(const ExportMetalCommandQueueInfoEXT& copy_src);
+    ExportMetalCommandQueueInfoEXT& operator=(const ExportMetalCommandQueueInfoEXT& copy_src);
+    ExportMetalCommandQueueInfoEXT();
+    ~ExportMetalCommandQueueInfoEXT();
+    void initialize(const VkExportMetalCommandQueueInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMetalCommandQueueInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalCommandQueueInfoEXT* ptr() { return reinterpret_cast<VkExportMetalCommandQueueInfoEXT*>(this); }
+    VkExportMetalCommandQueueInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalCommandQueueInfoEXT const*>(this); }
+};
+struct ExportMetalBufferInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    MTLBuffer_id mtlBuffer;
+
+    ExportMetalBufferInfoEXT(const VkExportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ExportMetalBufferInfoEXT(const ExportMetalBufferInfoEXT& copy_src);
+    ExportMetalBufferInfoEXT& operator=(const ExportMetalBufferInfoEXT& copy_src);
+    ExportMetalBufferInfoEXT();
+    ~ExportMetalBufferInfoEXT();
+    void initialize(const VkExportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMetalBufferInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalBufferInfoEXT* ptr() { return reinterpret_cast<VkExportMetalBufferInfoEXT*>(this); }
+    VkExportMetalBufferInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalBufferInfoEXT const*>(this); }
+};
+struct ImportMetalBufferInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    MTLBuffer_id mtlBuffer;
+
+    ImportMetalBufferInfoEXT(const VkImportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImportMetalBufferInfoEXT(const ImportMetalBufferInfoEXT& copy_src);
+    ImportMetalBufferInfoEXT& operator=(const ImportMetalBufferInfoEXT& copy_src);
+    ImportMetalBufferInfoEXT();
+    ~ImportMetalBufferInfoEXT();
+    void initialize(const VkImportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportMetalBufferInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImportMetalBufferInfoEXT* ptr() { return reinterpret_cast<VkImportMetalBufferInfoEXT*>(this); }
+    VkImportMetalBufferInfoEXT const* ptr() const { return reinterpret_cast<VkImportMetalBufferInfoEXT const*>(this); }
+};
+struct ExportMetalTextureInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    VkImageView imageView;
+    VkBufferView bufferView;
+    VkImageAspectFlagBits plane;
+    MTLTexture_id mtlTexture;
+
+    ExportMetalTextureInfoEXT(const VkExportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    ExportMetalTextureInfoEXT(const ExportMetalTextureInfoEXT& copy_src);
+    ExportMetalTextureInfoEXT& operator=(const ExportMetalTextureInfoEXT& copy_src);
+    ExportMetalTextureInfoEXT();
+    ~ExportMetalTextureInfoEXT();
+    void initialize(const VkExportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMetalTextureInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalTextureInfoEXT* ptr() { return reinterpret_cast<VkExportMetalTextureInfoEXT*>(this); }
+    VkExportMetalTextureInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalTextureInfoEXT const*>(this); }
+};
+struct ImportMetalTextureInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageAspectFlagBits plane;
+    MTLTexture_id mtlTexture;
+
+    ImportMetalTextureInfoEXT(const VkImportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    ImportMetalTextureInfoEXT(const ImportMetalTextureInfoEXT& copy_src);
+    ImportMetalTextureInfoEXT& operator=(const ImportMetalTextureInfoEXT& copy_src);
+    ImportMetalTextureInfoEXT();
+    ~ImportMetalTextureInfoEXT();
+    void initialize(const VkImportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportMetalTextureInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImportMetalTextureInfoEXT* ptr() { return reinterpret_cast<VkImportMetalTextureInfoEXT*>(this); }
+    VkImportMetalTextureInfoEXT const* ptr() const { return reinterpret_cast<VkImportMetalTextureInfoEXT const*>(this); }
+};
+struct ExportMetalIOSurfaceInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    IOSurfaceRef ioSurface;
+
+    ExportMetalIOSurfaceInfoEXT(const VkExportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    ExportMetalIOSurfaceInfoEXT(const ExportMetalIOSurfaceInfoEXT& copy_src);
+    ExportMetalIOSurfaceInfoEXT& operator=(const ExportMetalIOSurfaceInfoEXT& copy_src);
+    ExportMetalIOSurfaceInfoEXT();
+    ~ExportMetalIOSurfaceInfoEXT();
+    void initialize(const VkExportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMetalIOSurfaceInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalIOSurfaceInfoEXT* ptr() { return reinterpret_cast<VkExportMetalIOSurfaceInfoEXT*>(this); }
+    VkExportMetalIOSurfaceInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalIOSurfaceInfoEXT const*>(this); }
+};
+struct ImportMetalIOSurfaceInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    IOSurfaceRef ioSurface;
+
+    ImportMetalIOSurfaceInfoEXT(const VkImportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    ImportMetalIOSurfaceInfoEXT(const ImportMetalIOSurfaceInfoEXT& copy_src);
+    ImportMetalIOSurfaceInfoEXT& operator=(const ImportMetalIOSurfaceInfoEXT& copy_src);
+    ImportMetalIOSurfaceInfoEXT();
+    ~ImportMetalIOSurfaceInfoEXT();
+    void initialize(const VkImportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportMetalIOSurfaceInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImportMetalIOSurfaceInfoEXT* ptr() { return reinterpret_cast<VkImportMetalIOSurfaceInfoEXT*>(this); }
+    VkImportMetalIOSurfaceInfoEXT const* ptr() const { return reinterpret_cast<VkImportMetalIOSurfaceInfoEXT const*>(this); }
+};
+struct ExportMetalSharedEventInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkEvent event;
+    MTLSharedEvent_id mtlSharedEvent;
+
+    ExportMetalSharedEventInfoEXT(const VkExportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    ExportMetalSharedEventInfoEXT(const ExportMetalSharedEventInfoEXT& copy_src);
+    ExportMetalSharedEventInfoEXT& operator=(const ExportMetalSharedEventInfoEXT& copy_src);
+    ExportMetalSharedEventInfoEXT();
+    ~ExportMetalSharedEventInfoEXT();
+    void initialize(const VkExportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExportMetalSharedEventInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalSharedEventInfoEXT* ptr() { return reinterpret_cast<VkExportMetalSharedEventInfoEXT*>(this); }
+    VkExportMetalSharedEventInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalSharedEventInfoEXT const*>(this); }
+};
+struct ImportMetalSharedEventInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    MTLSharedEvent_id mtlSharedEvent;
+
+    ImportMetalSharedEventInfoEXT(const VkImportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    ImportMetalSharedEventInfoEXT(const ImportMetalSharedEventInfoEXT& copy_src);
+    ImportMetalSharedEventInfoEXT& operator=(const ImportMetalSharedEventInfoEXT& copy_src);
+    ImportMetalSharedEventInfoEXT();
+    ~ImportMetalSharedEventInfoEXT();
+    void initialize(const VkImportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportMetalSharedEventInfoEXT* 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 PhysicalDeviceDescriptorBufferPropertiesEXT {
+    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;
+
+    PhysicalDeviceDescriptorBufferPropertiesEXT(const VkPhysicalDeviceDescriptorBufferPropertiesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDescriptorBufferPropertiesEXT(const PhysicalDeviceDescriptorBufferPropertiesEXT& copy_src);
+    PhysicalDeviceDescriptorBufferPropertiesEXT& operator=(const PhysicalDeviceDescriptorBufferPropertiesEXT& copy_src);
+    PhysicalDeviceDescriptorBufferPropertiesEXT();
+    ~PhysicalDeviceDescriptorBufferPropertiesEXT();
+    void initialize(const VkPhysicalDeviceDescriptorBufferPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDescriptorBufferPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferPropertiesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    size_t combinedImageSamplerDensityMapDescriptorSize;
+
+    PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(const PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& copy_src);
+    PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& operator=(
+        const PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& copy_src);
+    PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT();
+    ~PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT();
+    void initialize(const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceDescriptorBufferFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 descriptorBuffer;
+    VkBool32 descriptorBufferCaptureReplay;
+    VkBool32 descriptorBufferImageLayoutIgnored;
+    VkBool32 descriptorBufferPushDescriptors;
+
+    PhysicalDeviceDescriptorBufferFeaturesEXT(const VkPhysicalDeviceDescriptorBufferFeaturesEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDescriptorBufferFeaturesEXT(const PhysicalDeviceDescriptorBufferFeaturesEXT& copy_src);
+    PhysicalDeviceDescriptorBufferFeaturesEXT& operator=(const PhysicalDeviceDescriptorBufferFeaturesEXT& copy_src);
+    PhysicalDeviceDescriptorBufferFeaturesEXT();
+    ~PhysicalDeviceDescriptorBufferFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDescriptorBufferFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDescriptorBufferFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT const*>(this);
+    }
+};
+struct DescriptorAddressInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceAddress address;
+    VkDeviceSize range;
+    VkFormat format;
+
+    DescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DescriptorAddressInfoEXT(const DescriptorAddressInfoEXT& copy_src);
+    DescriptorAddressInfoEXT& operator=(const DescriptorAddressInfoEXT& copy_src);
+    DescriptorAddressInfoEXT();
+    ~DescriptorAddressInfoEXT();
+    void initialize(const VkDescriptorAddressInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorAddressInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorAddressInfoEXT* ptr() { return reinterpret_cast<VkDescriptorAddressInfoEXT*>(this); }
+    VkDescriptorAddressInfoEXT const* ptr() const { return reinterpret_cast<VkDescriptorAddressInfoEXT const*>(this); }
+};
+struct DescriptorBufferBindingInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceAddress address;
+    VkBufferUsageFlags usage;
+
+    DescriptorBufferBindingInfoEXT(const VkDescriptorBufferBindingInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    DescriptorBufferBindingInfoEXT(const DescriptorBufferBindingInfoEXT& copy_src);
+    DescriptorBufferBindingInfoEXT& operator=(const DescriptorBufferBindingInfoEXT& copy_src);
+    DescriptorBufferBindingInfoEXT();
+    ~DescriptorBufferBindingInfoEXT();
+    void initialize(const VkDescriptorBufferBindingInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorBufferBindingInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorBufferBindingInfoEXT* ptr() { return reinterpret_cast<VkDescriptorBufferBindingInfoEXT*>(this); }
+    VkDescriptorBufferBindingInfoEXT const* ptr() const { return reinterpret_cast<VkDescriptorBufferBindingInfoEXT const*>(this); }
+};
+struct DescriptorBufferBindingPushDescriptorBufferHandleEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBuffer buffer;
+
+    DescriptorBufferBindingPushDescriptorBufferHandleEXT(const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DescriptorBufferBindingPushDescriptorBufferHandleEXT(const DescriptorBufferBindingPushDescriptorBufferHandleEXT& copy_src);
+    DescriptorBufferBindingPushDescriptorBufferHandleEXT& operator=(
+        const DescriptorBufferBindingPushDescriptorBufferHandleEXT& copy_src);
+    DescriptorBufferBindingPushDescriptorBufferHandleEXT();
+    ~DescriptorBufferBindingPushDescriptorBufferHandleEXT();
+    void initialize(const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorBufferBindingPushDescriptorBufferHandleEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* ptr() {
+        return reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(this);
+    }
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const* ptr() const {
+        return reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const*>(this);
+    }
+};
+union DescriptorDataEXT {
+    const VkSampler* pSampler{};
+    const VkDescriptorImageInfo* pCombinedImageSampler;
+    const VkDescriptorImageInfo* pInputAttachmentImage;
+    const VkDescriptorImageInfo* pSampledImage;
+    const VkDescriptorImageInfo* pStorageImage;
+    DescriptorAddressInfoEXT* pUniformTexelBuffer;
+    DescriptorAddressInfoEXT* pStorageTexelBuffer;
+    DescriptorAddressInfoEXT* pUniformBuffer;
+    DescriptorAddressInfoEXT* pStorageBuffer;
+    VkDeviceAddress accelerationStructure;
+    char type_at_end[sizeof(VkDescriptorDataEXT) + sizeof(VkDescriptorGetInfoEXT::type)];
+    DescriptorDataEXT(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {});
+    DescriptorDataEXT(const DescriptorDataEXT& copy_src);
+    DescriptorDataEXT& operator=(const DescriptorDataEXT& copy_src);
+    DescriptorDataEXT();
+    ~DescriptorDataEXT();
+    void initialize(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorDataEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorDataEXT* ptr() { return reinterpret_cast<VkDescriptorDataEXT*>(this); }
+    VkDescriptorDataEXT const* ptr() const { return reinterpret_cast<VkDescriptorDataEXT const*>(this); }
+};
+struct DescriptorGetInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorType type;
+    DescriptorDataEXT data;
+
+    DescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DescriptorGetInfoEXT(const DescriptorGetInfoEXT& copy_src);
+    DescriptorGetInfoEXT& operator=(const DescriptorGetInfoEXT& copy_src);
+    DescriptorGetInfoEXT();
+    ~DescriptorGetInfoEXT();
+    void initialize(const VkDescriptorGetInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorGetInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorGetInfoEXT* ptr() { return reinterpret_cast<VkDescriptorGetInfoEXT*>(this); }
+    VkDescriptorGetInfoEXT const* ptr() const { return reinterpret_cast<VkDescriptorGetInfoEXT const*>(this); }
+};
+struct BufferCaptureDescriptorDataInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer buffer;
+
+    BufferCaptureDescriptorDataInfoEXT(const VkBufferCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    BufferCaptureDescriptorDataInfoEXT(const BufferCaptureDescriptorDataInfoEXT& copy_src);
+    BufferCaptureDescriptorDataInfoEXT& operator=(const BufferCaptureDescriptorDataInfoEXT& copy_src);
+    BufferCaptureDescriptorDataInfoEXT();
+    ~BufferCaptureDescriptorDataInfoEXT();
+    void initialize(const VkBufferCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast<VkBufferCaptureDescriptorDataInfoEXT*>(this); }
+    VkBufferCaptureDescriptorDataInfoEXT const* ptr() const {
+        return reinterpret_cast<VkBufferCaptureDescriptorDataInfoEXT const*>(this);
+    }
+};
+struct ImageCaptureDescriptorDataInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+
+    ImageCaptureDescriptorDataInfoEXT(const VkImageCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    ImageCaptureDescriptorDataInfoEXT(const ImageCaptureDescriptorDataInfoEXT& copy_src);
+    ImageCaptureDescriptorDataInfoEXT& operator=(const ImageCaptureDescriptorDataInfoEXT& copy_src);
+    ImageCaptureDescriptorDataInfoEXT();
+    ~ImageCaptureDescriptorDataInfoEXT();
+    void initialize(const VkImageCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast<VkImageCaptureDescriptorDataInfoEXT*>(this); }
+    VkImageCaptureDescriptorDataInfoEXT const* ptr() const {
+        return reinterpret_cast<VkImageCaptureDescriptorDataInfoEXT const*>(this);
+    }
+};
+struct ImageViewCaptureDescriptorDataInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+
+    ImageViewCaptureDescriptorDataInfoEXT(const VkImageViewCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    ImageViewCaptureDescriptorDataInfoEXT(const ImageViewCaptureDescriptorDataInfoEXT& copy_src);
+    ImageViewCaptureDescriptorDataInfoEXT& operator=(const ImageViewCaptureDescriptorDataInfoEXT& copy_src);
+    ImageViewCaptureDescriptorDataInfoEXT();
+    ~ImageViewCaptureDescriptorDataInfoEXT();
+    void initialize(const VkImageViewCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageViewCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast<VkImageViewCaptureDescriptorDataInfoEXT*>(this); }
+    VkImageViewCaptureDescriptorDataInfoEXT const* ptr() const {
+        return reinterpret_cast<VkImageViewCaptureDescriptorDataInfoEXT const*>(this);
+    }
+};
+struct SamplerCaptureDescriptorDataInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSampler sampler;
+
+    SamplerCaptureDescriptorDataInfoEXT(const VkSamplerCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    SamplerCaptureDescriptorDataInfoEXT(const SamplerCaptureDescriptorDataInfoEXT& copy_src);
+    SamplerCaptureDescriptorDataInfoEXT& operator=(const SamplerCaptureDescriptorDataInfoEXT& copy_src);
+    SamplerCaptureDescriptorDataInfoEXT();
+    ~SamplerCaptureDescriptorDataInfoEXT();
+    void initialize(const VkSamplerCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SamplerCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast<VkSamplerCaptureDescriptorDataInfoEXT*>(this); }
+    VkSamplerCaptureDescriptorDataInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSamplerCaptureDescriptorDataInfoEXT const*>(this);
+    }
+};
+struct OpaqueCaptureDescriptorDataCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    const void* opaqueCaptureDescriptorData{};
+
+    OpaqueCaptureDescriptorDataCreateInfoEXT(const VkOpaqueCaptureDescriptorDataCreateInfoEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    OpaqueCaptureDescriptorDataCreateInfoEXT(const OpaqueCaptureDescriptorDataCreateInfoEXT& copy_src);
+    OpaqueCaptureDescriptorDataCreateInfoEXT& operator=(const OpaqueCaptureDescriptorDataCreateInfoEXT& copy_src);
+    OpaqueCaptureDescriptorDataCreateInfoEXT();
+    ~OpaqueCaptureDescriptorDataCreateInfoEXT();
+    void initialize(const VkOpaqueCaptureDescriptorDataCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const OpaqueCaptureDescriptorDataCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(this);
+    }
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkOpaqueCaptureDescriptorDataCreateInfoEXT const*>(this);
+    }
+};
+struct AccelerationStructureCaptureDescriptorDataInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureKHR accelerationStructure;
+    VkAccelerationStructureNV accelerationStructureNV;
+
+    AccelerationStructureCaptureDescriptorDataInfoEXT(const VkAccelerationStructureCaptureDescriptorDataInfoEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureCaptureDescriptorDataInfoEXT(const AccelerationStructureCaptureDescriptorDataInfoEXT& copy_src);
+    AccelerationStructureCaptureDescriptorDataInfoEXT& operator=(const AccelerationStructureCaptureDescriptorDataInfoEXT& copy_src);
+    AccelerationStructureCaptureDescriptorDataInfoEXT();
+    ~AccelerationStructureCaptureDescriptorDataInfoEXT();
+    void initialize(const VkAccelerationStructureCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* ptr() {
+        return reinterpret_cast<VkAccelerationStructureCaptureDescriptorDataInfoEXT*>(this);
+    }
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureCaptureDescriptorDataInfoEXT const*>(this);
+    }
+};
+struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 graphicsPipelineLibrary;
+
+    PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(const PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& copy_src);
+    PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& operator=(const PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& copy_src);
+    PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT();
+    ~PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT();
+    void initialize(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 graphicsPipelineLibraryFastLinking;
+    VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration;
+
+    PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(const PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& copy_src);
+    PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& operator=(
+        const PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& copy_src);
+    PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT();
+    ~PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT();
+    void initialize(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const*>(this);
+    }
+};
+struct GraphicsPipelineLibraryCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkGraphicsPipelineLibraryFlagsEXT flags;
+
+    GraphicsPipelineLibraryCreateInfoEXT(const VkGraphicsPipelineLibraryCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    GraphicsPipelineLibraryCreateInfoEXT(const GraphicsPipelineLibraryCreateInfoEXT& copy_src);
+    GraphicsPipelineLibraryCreateInfoEXT& operator=(const GraphicsPipelineLibraryCreateInfoEXT& copy_src);
+    GraphicsPipelineLibraryCreateInfoEXT();
+    ~GraphicsPipelineLibraryCreateInfoEXT();
+    void initialize(const VkGraphicsPipelineLibraryCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const GraphicsPipelineLibraryCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkGraphicsPipelineLibraryCreateInfoEXT* ptr() { return reinterpret_cast<VkGraphicsPipelineLibraryCreateInfoEXT*>(this); }
+    VkGraphicsPipelineLibraryCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkGraphicsPipelineLibraryCreateInfoEXT const*>(this);
+    }
+};
+struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderEarlyAndLateFragmentTests;
+
+    PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+        const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+        const PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& copy_src);
+    PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& operator=(
+        const PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& copy_src);
+    PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD();
+    ~PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD();
+    void initialize(const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(this);
+    }
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const*>(this);
+    }
+};
+struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentShadingRateEnums;
+    VkBool32 supersampleFragmentShadingRates;
+    VkBool32 noInvocationFragmentShadingRates;
+
+    PhysicalDeviceFragmentShadingRateEnumsFeaturesNV(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentShadingRateEnumsFeaturesNV(const PhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src);
+    PhysicalDeviceFragmentShadingRateEnumsFeaturesNV& operator=(const PhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src);
+    PhysicalDeviceFragmentShadingRateEnumsFeaturesNV();
+    ~PhysicalDeviceFragmentShadingRateEnumsFeaturesNV();
+    void initialize(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentShadingRateEnumsFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;
+
+    PhysicalDeviceFragmentShadingRateEnumsPropertiesNV(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentShadingRateEnumsPropertiesNV(const PhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src);
+    PhysicalDeviceFragmentShadingRateEnumsPropertiesNV& operator=(
+        const PhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src);
+    PhysicalDeviceFragmentShadingRateEnumsPropertiesNV();
+    ~PhysicalDeviceFragmentShadingRateEnumsPropertiesNV();
+    void initialize(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentShadingRateEnumsPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const*>(this);
+    }
+};
+struct PipelineFragmentShadingRateEnumStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFragmentShadingRateTypeNV shadingRateType;
+    VkFragmentShadingRateNV shadingRate;
+    VkFragmentShadingRateCombinerOpKHR combinerOps[2];
+
+    PipelineFragmentShadingRateEnumStateCreateInfoNV(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineFragmentShadingRateEnumStateCreateInfoNV(const PipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src);
+    PipelineFragmentShadingRateEnumStateCreateInfoNV& operator=(const PipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src);
+    PipelineFragmentShadingRateEnumStateCreateInfoNV();
+    ~PipelineFragmentShadingRateEnumStateCreateInfoNV();
+    void initialize(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineFragmentShadingRateEnumStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineFragmentShadingRateEnumStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(this);
+    }
+    VkPipelineFragmentShadingRateEnumStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV const*>(this);
+    }
+};
+union DeviceOrHostAddressConstKHR {
+    VkDeviceAddress deviceAddress;
+    const void* hostAddress{};
+
+    DeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct, PNextCopyState* copy_state = {});
+    DeviceOrHostAddressConstKHR(const DeviceOrHostAddressConstKHR& copy_src);
+    DeviceOrHostAddressConstKHR& operator=(const DeviceOrHostAddressConstKHR& copy_src);
+    DeviceOrHostAddressConstKHR();
+    ~DeviceOrHostAddressConstKHR();
+    void initialize(const VkDeviceOrHostAddressConstKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceOrHostAddressConstKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceOrHostAddressConstKHR* ptr() { return reinterpret_cast<VkDeviceOrHostAddressConstKHR*>(this); }
+    VkDeviceOrHostAddressConstKHR const* ptr() const { return reinterpret_cast<VkDeviceOrHostAddressConstKHR const*>(this); }
+};
+struct AccelerationStructureGeometryMotionTrianglesDataNV {
+    VkStructureType sType;
+    const void* pNext{};
+    DeviceOrHostAddressConstKHR vertexData;
+
+    AccelerationStructureGeometryMotionTrianglesDataNV(const VkAccelerationStructureGeometryMotionTrianglesDataNV* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureGeometryMotionTrianglesDataNV(const AccelerationStructureGeometryMotionTrianglesDataNV& copy_src);
+    AccelerationStructureGeometryMotionTrianglesDataNV& operator=(
+        const AccelerationStructureGeometryMotionTrianglesDataNV& copy_src);
+    AccelerationStructureGeometryMotionTrianglesDataNV();
+    ~AccelerationStructureGeometryMotionTrianglesDataNV();
+    void initialize(const VkAccelerationStructureGeometryMotionTrianglesDataNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureGeometryMotionTrianglesDataNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometryMotionTrianglesDataNV* ptr() {
+        return reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(this);
+    }
+    VkAccelerationStructureGeometryMotionTrianglesDataNV const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV const*>(this);
+    }
+};
+struct AccelerationStructureMotionInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxInstances;
+    VkAccelerationStructureMotionInfoFlagsNV flags;
+
+    AccelerationStructureMotionInfoNV(const VkAccelerationStructureMotionInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    AccelerationStructureMotionInfoNV(const AccelerationStructureMotionInfoNV& copy_src);
+    AccelerationStructureMotionInfoNV& operator=(const AccelerationStructureMotionInfoNV& copy_src);
+    AccelerationStructureMotionInfoNV();
+    ~AccelerationStructureMotionInfoNV();
+    void initialize(const VkAccelerationStructureMotionInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureMotionInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureMotionInfoNV* ptr() { return reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(this); }
+    VkAccelerationStructureMotionInfoNV const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureMotionInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceRayTracingMotionBlurFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingMotionBlur;
+    VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect;
+
+    PhysicalDeviceRayTracingMotionBlurFeaturesNV(const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRayTracingMotionBlurFeaturesNV(const PhysicalDeviceRayTracingMotionBlurFeaturesNV& copy_src);
+    PhysicalDeviceRayTracingMotionBlurFeaturesNV& operator=(const PhysicalDeviceRayTracingMotionBlurFeaturesNV& copy_src);
+    PhysicalDeviceRayTracingMotionBlurFeaturesNV();
+    ~PhysicalDeviceRayTracingMotionBlurFeaturesNV();
+    void initialize(const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRayTracingMotionBlurFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 ycbcr2plane444Formats;
+
+    PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src);
+    PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& operator=(const PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src);
+    PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT();
+    ~PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT();
+    void initialize(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceFragmentDensityMap2FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentDensityMapDeferred;
+
+    PhysicalDeviceFragmentDensityMap2FeaturesEXT(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentDensityMap2FeaturesEXT(const PhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src);
+    PhysicalDeviceFragmentDensityMap2FeaturesEXT& operator=(const PhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src);
+    PhysicalDeviceFragmentDensityMap2FeaturesEXT();
+    ~PhysicalDeviceFragmentDensityMap2FeaturesEXT();
+    void initialize(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentDensityMap2FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceFragmentDensityMap2PropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 subsampledLoads;
+    VkBool32 subsampledCoarseReconstructionEarlyAccess;
+    uint32_t maxSubsampledArrayLayers;
+    uint32_t maxDescriptorSetSubsampledSamplers;
+
+    PhysicalDeviceFragmentDensityMap2PropertiesEXT(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentDensityMap2PropertiesEXT(const PhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src);
+    PhysicalDeviceFragmentDensityMap2PropertiesEXT& operator=(const PhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src);
+    PhysicalDeviceFragmentDensityMap2PropertiesEXT();
+    ~PhysicalDeviceFragmentDensityMap2PropertiesEXT();
+    void initialize(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentDensityMap2PropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const*>(this);
+    }
+};
+struct CopyCommandTransformInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSurfaceTransformFlagBitsKHR transform;
+
+    CopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    CopyCommandTransformInfoQCOM(const CopyCommandTransformInfoQCOM& copy_src);
+    CopyCommandTransformInfoQCOM& operator=(const CopyCommandTransformInfoQCOM& copy_src);
+    CopyCommandTransformInfoQCOM();
+    ~CopyCommandTransformInfoQCOM();
+    void initialize(const VkCopyCommandTransformInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyCommandTransformInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkCopyCommandTransformInfoQCOM* ptr() { return reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(this); }
+    VkCopyCommandTransformInfoQCOM const* ptr() const { return reinterpret_cast<VkCopyCommandTransformInfoQCOM const*>(this); }
+};
+struct PhysicalDeviceImageCompressionControlFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 imageCompressionControl;
+
+    PhysicalDeviceImageCompressionControlFeaturesEXT(const VkPhysicalDeviceImageCompressionControlFeaturesEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceImageCompressionControlFeaturesEXT(const PhysicalDeviceImageCompressionControlFeaturesEXT& copy_src);
+    PhysicalDeviceImageCompressionControlFeaturesEXT& operator=(const PhysicalDeviceImageCompressionControlFeaturesEXT& copy_src);
+    PhysicalDeviceImageCompressionControlFeaturesEXT();
+    ~PhysicalDeviceImageCompressionControlFeaturesEXT();
+    void initialize(const VkPhysicalDeviceImageCompressionControlFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageCompressionControlFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT const*>(this);
+    }
+};
+struct ImageCompressionControlEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageCompressionFlagsEXT flags;
+    uint32_t compressionControlPlaneCount;
+    VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags{};
+
+    ImageCompressionControlEXT(const VkImageCompressionControlEXT* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    ImageCompressionControlEXT(const ImageCompressionControlEXT& copy_src);
+    ImageCompressionControlEXT& operator=(const ImageCompressionControlEXT& copy_src);
+    ImageCompressionControlEXT();
+    ~ImageCompressionControlEXT();
+    void initialize(const VkImageCompressionControlEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageCompressionControlEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageCompressionControlEXT* ptr() { return reinterpret_cast<VkImageCompressionControlEXT*>(this); }
+    VkImageCompressionControlEXT const* ptr() const { return reinterpret_cast<VkImageCompressionControlEXT const*>(this); }
+};
+struct ImageCompressionPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageCompressionFlagsEXT imageCompressionFlags;
+    VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags;
+
+    ImageCompressionPropertiesEXT(const VkImageCompressionPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    ImageCompressionPropertiesEXT(const ImageCompressionPropertiesEXT& copy_src);
+    ImageCompressionPropertiesEXT& operator=(const ImageCompressionPropertiesEXT& copy_src);
+    ImageCompressionPropertiesEXT();
+    ~ImageCompressionPropertiesEXT();
+    void initialize(const VkImageCompressionPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageCompressionPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageCompressionPropertiesEXT* ptr() { return reinterpret_cast<VkImageCompressionPropertiesEXT*>(this); }
+    VkImageCompressionPropertiesEXT const* ptr() const { return reinterpret_cast<VkImageCompressionPropertiesEXT const*>(this); }
+};
+struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 attachmentFeedbackLoopLayout;
+
+    PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(const PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& copy_src);
+    PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& operator=(
+        const PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& copy_src);
+    PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT();
+    ~PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT();
+    void initialize(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDevice4444FormatsFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 formatA4R4G4B4;
+    VkBool32 formatA4B4G4R4;
+
+    PhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDevice4444FormatsFeaturesEXT(const PhysicalDevice4444FormatsFeaturesEXT& copy_src);
+    PhysicalDevice4444FormatsFeaturesEXT& operator=(const PhysicalDevice4444FormatsFeaturesEXT& copy_src);
+    PhysicalDevice4444FormatsFeaturesEXT();
+    ~PhysicalDevice4444FormatsFeaturesEXT();
+    void initialize(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevice4444FormatsFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevice4444FormatsFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(this); }
+    VkPhysicalDevice4444FormatsFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceFaultFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 deviceFault;
+    VkBool32 deviceFaultVendorBinary;
+
+    PhysicalDeviceFaultFeaturesEXT(const VkPhysicalDeviceFaultFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    PhysicalDeviceFaultFeaturesEXT(const PhysicalDeviceFaultFeaturesEXT& copy_src);
+    PhysicalDeviceFaultFeaturesEXT& operator=(const PhysicalDeviceFaultFeaturesEXT& copy_src);
+    PhysicalDeviceFaultFeaturesEXT();
+    ~PhysicalDeviceFaultFeaturesEXT();
+    void initialize(const VkPhysicalDeviceFaultFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFaultFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFaultFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceFaultFeaturesEXT*>(this); }
+    VkPhysicalDeviceFaultFeaturesEXT const* ptr() const { return reinterpret_cast<VkPhysicalDeviceFaultFeaturesEXT const*>(this); }
+};
+struct DeviceFaultCountsEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t addressInfoCount;
+    uint32_t vendorInfoCount;
+    VkDeviceSize vendorBinarySize;
+
+    DeviceFaultCountsEXT(const VkDeviceFaultCountsEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DeviceFaultCountsEXT(const DeviceFaultCountsEXT& copy_src);
+    DeviceFaultCountsEXT& operator=(const DeviceFaultCountsEXT& copy_src);
+    DeviceFaultCountsEXT();
+    ~DeviceFaultCountsEXT();
+    void initialize(const VkDeviceFaultCountsEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceFaultCountsEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceFaultCountsEXT* ptr() { return reinterpret_cast<VkDeviceFaultCountsEXT*>(this); }
+    VkDeviceFaultCountsEXT const* ptr() const { return reinterpret_cast<VkDeviceFaultCountsEXT const*>(this); }
+};
+struct DeviceFaultInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkDeviceFaultAddressInfoEXT* pAddressInfos{};
+    VkDeviceFaultVendorInfoEXT* pVendorInfos{};
+    void* pVendorBinaryData{};
+
+    DeviceFaultInfoEXT(const VkDeviceFaultInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DeviceFaultInfoEXT(const DeviceFaultInfoEXT& copy_src);
+    DeviceFaultInfoEXT& operator=(const DeviceFaultInfoEXT& copy_src);
+    DeviceFaultInfoEXT();
+    ~DeviceFaultInfoEXT();
+    void initialize(const VkDeviceFaultInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceFaultInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceFaultInfoEXT* ptr() { return reinterpret_cast<VkDeviceFaultInfoEXT*>(this); }
+    VkDeviceFaultInfoEXT const* ptr() const { return reinterpret_cast<VkDeviceFaultInfoEXT const*>(this); }
+};
+struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rasterizationOrderColorAttachmentAccess;
+    VkBool32 rasterizationOrderDepthAttachmentAccess;
+    VkBool32 rasterizationOrderStencilAttachmentAccess;
+
+    PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+        const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+        const PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& copy_src);
+    PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& operator=(
+        const PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& copy_src);
+    PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT();
+    ~PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT();
+    void initialize(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* in_struct,
+                    PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 formatRgba10x6WithoutYCbCrSampler;
+
+    PhysicalDeviceRGBA10X6FormatsFeaturesEXT(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRGBA10X6FormatsFeaturesEXT(const PhysicalDeviceRGBA10X6FormatsFeaturesEXT& copy_src);
+    PhysicalDeviceRGBA10X6FormatsFeaturesEXT& operator=(const PhysicalDeviceRGBA10X6FormatsFeaturesEXT& copy_src);
+    PhysicalDeviceRGBA10X6FormatsFeaturesEXT();
+    ~PhysicalDeviceRGBA10X6FormatsFeaturesEXT();
+    void initialize(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRGBA10X6FormatsFeaturesEXT* 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 DirectFBSurfaceCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDirectFBSurfaceCreateFlagsEXT flags;
+    IDirectFB* dfb{};
+    IDirectFBSurface* surface{};
+
+    DirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    DirectFBSurfaceCreateInfoEXT(const DirectFBSurfaceCreateInfoEXT& copy_src);
+    DirectFBSurfaceCreateInfoEXT& operator=(const DirectFBSurfaceCreateInfoEXT& copy_src);
+    DirectFBSurfaceCreateInfoEXT();
+    ~DirectFBSurfaceCreateInfoEXT();
+    void initialize(const VkDirectFBSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DirectFBSurfaceCreateInfoEXT* 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 PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 mutableDescriptorType;
+
+    PhysicalDeviceMutableDescriptorTypeFeaturesEXT(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMutableDescriptorTypeFeaturesEXT(const PhysicalDeviceMutableDescriptorTypeFeaturesEXT& copy_src);
+    PhysicalDeviceMutableDescriptorTypeFeaturesEXT& operator=(const PhysicalDeviceMutableDescriptorTypeFeaturesEXT& copy_src);
+    PhysicalDeviceMutableDescriptorTypeFeaturesEXT();
+    ~PhysicalDeviceMutableDescriptorTypeFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMutableDescriptorTypeFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const*>(this);
+    }
+};
+struct MutableDescriptorTypeListEXT {
+    uint32_t descriptorTypeCount;
+    const VkDescriptorType* pDescriptorTypes{};
+
+    MutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT* in_struct, PNextCopyState* copy_state = {});
+    MutableDescriptorTypeListEXT(const MutableDescriptorTypeListEXT& copy_src);
+    MutableDescriptorTypeListEXT& operator=(const MutableDescriptorTypeListEXT& copy_src);
+    MutableDescriptorTypeListEXT();
+    ~MutableDescriptorTypeListEXT();
+    void initialize(const VkMutableDescriptorTypeListEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MutableDescriptorTypeListEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMutableDescriptorTypeListEXT* ptr() { return reinterpret_cast<VkMutableDescriptorTypeListEXT*>(this); }
+    VkMutableDescriptorTypeListEXT const* ptr() const { return reinterpret_cast<VkMutableDescriptorTypeListEXT const*>(this); }
+};
+struct MutableDescriptorTypeCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t mutableDescriptorTypeListCount;
+    MutableDescriptorTypeListEXT* pMutableDescriptorTypeLists{};
+
+    MutableDescriptorTypeCreateInfoEXT(const VkMutableDescriptorTypeCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    MutableDescriptorTypeCreateInfoEXT(const MutableDescriptorTypeCreateInfoEXT& copy_src);
+    MutableDescriptorTypeCreateInfoEXT& operator=(const MutableDescriptorTypeCreateInfoEXT& copy_src);
+    MutableDescriptorTypeCreateInfoEXT();
+    ~MutableDescriptorTypeCreateInfoEXT();
+    void initialize(const VkMutableDescriptorTypeCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MutableDescriptorTypeCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMutableDescriptorTypeCreateInfoEXT* ptr() { return reinterpret_cast<VkMutableDescriptorTypeCreateInfoEXT*>(this); }
+    VkMutableDescriptorTypeCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkMutableDescriptorTypeCreateInfoEXT const*>(this);
+    }
+};
+struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 vertexInputDynamicState;
+
+    PhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceVertexInputDynamicStateFeaturesEXT(const PhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src);
+    PhysicalDeviceVertexInputDynamicStateFeaturesEXT& operator=(const PhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src);
+    PhysicalDeviceVertexInputDynamicStateFeaturesEXT();
+    ~PhysicalDeviceVertexInputDynamicStateFeaturesEXT();
+    void initialize(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceVertexInputDynamicStateFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const*>(this);
+    }
+};
+struct VertexInputBindingDescription2EXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t binding;
+    uint32_t stride;
+    VkVertexInputRate inputRate;
+    uint32_t divisor;
+
+    VertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    VertexInputBindingDescription2EXT(const VertexInputBindingDescription2EXT& copy_src);
+    VertexInputBindingDescription2EXT& operator=(const VertexInputBindingDescription2EXT& copy_src);
+    VertexInputBindingDescription2EXT();
+    ~VertexInputBindingDescription2EXT();
+    void initialize(const VkVertexInputBindingDescription2EXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VertexInputBindingDescription2EXT* copy_src, PNextCopyState* copy_state = {});
+    VkVertexInputBindingDescription2EXT* ptr() { return reinterpret_cast<VkVertexInputBindingDescription2EXT*>(this); }
+    VkVertexInputBindingDescription2EXT const* ptr() const {
+        return reinterpret_cast<VkVertexInputBindingDescription2EXT const*>(this);
+    }
+};
+struct VertexInputAttributeDescription2EXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t location;
+    uint32_t binding;
+    VkFormat format;
+    uint32_t offset;
+
+    VertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    VertexInputAttributeDescription2EXT(const VertexInputAttributeDescription2EXT& copy_src);
+    VertexInputAttributeDescription2EXT& operator=(const VertexInputAttributeDescription2EXT& copy_src);
+    VertexInputAttributeDescription2EXT();
+    ~VertexInputAttributeDescription2EXT();
+    void initialize(const VkVertexInputAttributeDescription2EXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const VertexInputAttributeDescription2EXT* copy_src, PNextCopyState* copy_state = {});
+    VkVertexInputAttributeDescription2EXT* ptr() { return reinterpret_cast<VkVertexInputAttributeDescription2EXT*>(this); }
+    VkVertexInputAttributeDescription2EXT const* ptr() const {
+        return reinterpret_cast<VkVertexInputAttributeDescription2EXT const*>(this);
+    }
+};
+struct PhysicalDeviceDrmPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hasPrimary;
+    VkBool32 hasRender;
+    int64_t primaryMajor;
+    int64_t primaryMinor;
+    int64_t renderMajor;
+    int64_t renderMinor;
+
+    PhysicalDeviceDrmPropertiesEXT(const VkPhysicalDeviceDrmPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    PhysicalDeviceDrmPropertiesEXT(const PhysicalDeviceDrmPropertiesEXT& copy_src);
+    PhysicalDeviceDrmPropertiesEXT& operator=(const PhysicalDeviceDrmPropertiesEXT& copy_src);
+    PhysicalDeviceDrmPropertiesEXT();
+    ~PhysicalDeviceDrmPropertiesEXT();
+    void initialize(const VkPhysicalDeviceDrmPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDrmPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDrmPropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(this); }
+    VkPhysicalDeviceDrmPropertiesEXT const* ptr() const { return reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT const*>(this); }
+};
+struct PhysicalDeviceAddressBindingReportFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 reportAddressBinding;
+
+    PhysicalDeviceAddressBindingReportFeaturesEXT(const VkPhysicalDeviceAddressBindingReportFeaturesEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceAddressBindingReportFeaturesEXT(const PhysicalDeviceAddressBindingReportFeaturesEXT& copy_src);
+    PhysicalDeviceAddressBindingReportFeaturesEXT& operator=(const PhysicalDeviceAddressBindingReportFeaturesEXT& copy_src);
+    PhysicalDeviceAddressBindingReportFeaturesEXT();
+    ~PhysicalDeviceAddressBindingReportFeaturesEXT();
+    void initialize(const VkPhysicalDeviceAddressBindingReportFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceAddressBindingReportFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT const*>(this);
+    }
+};
+struct DeviceAddressBindingCallbackDataEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceAddressBindingFlagsEXT flags;
+    VkDeviceAddress baseAddress;
+    VkDeviceSize size;
+    VkDeviceAddressBindingTypeEXT bindingType;
+
+    DeviceAddressBindingCallbackDataEXT(const VkDeviceAddressBindingCallbackDataEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    DeviceAddressBindingCallbackDataEXT(const DeviceAddressBindingCallbackDataEXT& copy_src);
+    DeviceAddressBindingCallbackDataEXT& operator=(const DeviceAddressBindingCallbackDataEXT& copy_src);
+    DeviceAddressBindingCallbackDataEXT();
+    ~DeviceAddressBindingCallbackDataEXT();
+    void initialize(const VkDeviceAddressBindingCallbackDataEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceAddressBindingCallbackDataEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceAddressBindingCallbackDataEXT* ptr() { return reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT*>(this); }
+    VkDeviceAddressBindingCallbackDataEXT const* ptr() const {
+        return reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT const*>(this);
+    }
+};
+struct PhysicalDeviceDepthClipControlFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 depthClipControl;
+
+    PhysicalDeviceDepthClipControlFeaturesEXT(const VkPhysicalDeviceDepthClipControlFeaturesEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDepthClipControlFeaturesEXT(const PhysicalDeviceDepthClipControlFeaturesEXT& copy_src);
+    PhysicalDeviceDepthClipControlFeaturesEXT& operator=(const PhysicalDeviceDepthClipControlFeaturesEXT& copy_src);
+    PhysicalDeviceDepthClipControlFeaturesEXT();
+    ~PhysicalDeviceDepthClipControlFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDepthClipControlFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDepthClipControlFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDepthClipControlFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT const*>(this);
+    }
+};
+struct PipelineViewportDepthClipControlCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 negativeOneToOne;
+
+    PipelineViewportDepthClipControlCreateInfoEXT(const VkPipelineViewportDepthClipControlCreateInfoEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineViewportDepthClipControlCreateInfoEXT(const PipelineViewportDepthClipControlCreateInfoEXT& copy_src);
+    PipelineViewportDepthClipControlCreateInfoEXT& operator=(const PipelineViewportDepthClipControlCreateInfoEXT& copy_src);
+    PipelineViewportDepthClipControlCreateInfoEXT();
+    ~PipelineViewportDepthClipControlCreateInfoEXT();
+    void initialize(const VkPipelineViewportDepthClipControlCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineViewportDepthClipControlCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportDepthClipControlCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT*>(this);
+    }
+    VkPipelineViewportDepthClipControlCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT const*>(this);
+    }
+};
+struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 primitiveTopologyListRestart;
+    VkBool32 primitiveTopologyPatchListRestart;
+
+    PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(const PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& copy_src);
+    PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& operator=(
+        const PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& copy_src);
+    PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT();
+    ~PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT();
+    void initialize(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* 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 ImportMemoryZirconHandleInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+    zx_handle_t handle;
+
+    ImportMemoryZirconHandleInfoFUCHSIA(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    ImportMemoryZirconHandleInfoFUCHSIA(const ImportMemoryZirconHandleInfoFUCHSIA& copy_src);
+    ImportMemoryZirconHandleInfoFUCHSIA& operator=(const ImportMemoryZirconHandleInfoFUCHSIA& copy_src);
+    ImportMemoryZirconHandleInfoFUCHSIA();
+    ~ImportMemoryZirconHandleInfoFUCHSIA();
+    void initialize(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportMemoryZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(this); }
+    VkImportMemoryZirconHandleInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA const*>(this);
+    }
+};
+struct MemoryZirconHandlePropertiesFUCHSIA {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryTypeBits;
+
+    MemoryZirconHandlePropertiesFUCHSIA(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    MemoryZirconHandlePropertiesFUCHSIA(const MemoryZirconHandlePropertiesFUCHSIA& copy_src);
+    MemoryZirconHandlePropertiesFUCHSIA& operator=(const MemoryZirconHandlePropertiesFUCHSIA& copy_src);
+    MemoryZirconHandlePropertiesFUCHSIA();
+    ~MemoryZirconHandlePropertiesFUCHSIA();
+    void initialize(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryZirconHandlePropertiesFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryZirconHandlePropertiesFUCHSIA* ptr() { return reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA*>(this); }
+    VkMemoryZirconHandlePropertiesFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA const*>(this);
+    }
+};
+struct MemoryGetZirconHandleInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    MemoryGetZirconHandleInfoFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    MemoryGetZirconHandleInfoFUCHSIA(const MemoryGetZirconHandleInfoFUCHSIA& copy_src);
+    MemoryGetZirconHandleInfoFUCHSIA& operator=(const MemoryGetZirconHandleInfoFUCHSIA& copy_src);
+    MemoryGetZirconHandleInfoFUCHSIA();
+    ~MemoryGetZirconHandleInfoFUCHSIA();
+    void initialize(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryGetZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryGetZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast<VkMemoryGetZirconHandleInfoFUCHSIA*>(this); }
+    VkMemoryGetZirconHandleInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkMemoryGetZirconHandleInfoFUCHSIA const*>(this);
+    }
+};
+struct ImportSemaphoreZirconHandleInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkSemaphoreImportFlags flags;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+    zx_handle_t zirconHandle;
+
+    ImportSemaphoreZirconHandleInfoFUCHSIA(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ImportSemaphoreZirconHandleInfoFUCHSIA(const ImportSemaphoreZirconHandleInfoFUCHSIA& copy_src);
+    ImportSemaphoreZirconHandleInfoFUCHSIA& operator=(const ImportSemaphoreZirconHandleInfoFUCHSIA& copy_src);
+    ImportSemaphoreZirconHandleInfoFUCHSIA();
+    ~ImportSemaphoreZirconHandleInfoFUCHSIA();
+    void initialize(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportSemaphoreZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkImportSemaphoreZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast<VkImportSemaphoreZirconHandleInfoFUCHSIA*>(this); }
+    VkImportSemaphoreZirconHandleInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkImportSemaphoreZirconHandleInfoFUCHSIA const*>(this);
+    }
+};
+struct SemaphoreGetZirconHandleInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+
+    SemaphoreGetZirconHandleInfoFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    SemaphoreGetZirconHandleInfoFUCHSIA(const SemaphoreGetZirconHandleInfoFUCHSIA& copy_src);
+    SemaphoreGetZirconHandleInfoFUCHSIA& operator=(const SemaphoreGetZirconHandleInfoFUCHSIA& copy_src);
+    SemaphoreGetZirconHandleInfoFUCHSIA();
+    ~SemaphoreGetZirconHandleInfoFUCHSIA();
+    void initialize(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SemaphoreGetZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreGetZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast<VkSemaphoreGetZirconHandleInfoFUCHSIA*>(this); }
+    VkSemaphoreGetZirconHandleInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkSemaphoreGetZirconHandleInfoFUCHSIA const*>(this);
+    }
+};
+struct BufferCollectionCreateInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    zx_handle_t collectionToken;
+
+    BufferCollectionCreateInfoFUCHSIA(const VkBufferCollectionCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    BufferCollectionCreateInfoFUCHSIA(const BufferCollectionCreateInfoFUCHSIA& copy_src);
+    BufferCollectionCreateInfoFUCHSIA& operator=(const BufferCollectionCreateInfoFUCHSIA& copy_src);
+    BufferCollectionCreateInfoFUCHSIA();
+    ~BufferCollectionCreateInfoFUCHSIA();
+    void initialize(const VkBufferCollectionCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferCollectionCreateInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCollectionCreateInfoFUCHSIA* ptr() { return reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA*>(this); }
+    VkBufferCollectionCreateInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA const*>(this);
+    }
+};
+struct ImportMemoryBufferCollectionFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferCollectionFUCHSIA collection;
+    uint32_t index;
+
+    ImportMemoryBufferCollectionFUCHSIA(const VkImportMemoryBufferCollectionFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    ImportMemoryBufferCollectionFUCHSIA(const ImportMemoryBufferCollectionFUCHSIA& copy_src);
+    ImportMemoryBufferCollectionFUCHSIA& operator=(const ImportMemoryBufferCollectionFUCHSIA& copy_src);
+    ImportMemoryBufferCollectionFUCHSIA();
+    ~ImportMemoryBufferCollectionFUCHSIA();
+    void initialize(const VkImportMemoryBufferCollectionFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportMemoryBufferCollectionFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryBufferCollectionFUCHSIA* ptr() { return reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(this); }
+    VkImportMemoryBufferCollectionFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA const*>(this);
+    }
+};
+struct BufferCollectionImageCreateInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferCollectionFUCHSIA collection;
+    uint32_t index;
+
+    BufferCollectionImageCreateInfoFUCHSIA(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BufferCollectionImageCreateInfoFUCHSIA(const BufferCollectionImageCreateInfoFUCHSIA& copy_src);
+    BufferCollectionImageCreateInfoFUCHSIA& operator=(const BufferCollectionImageCreateInfoFUCHSIA& copy_src);
+    BufferCollectionImageCreateInfoFUCHSIA();
+    ~BufferCollectionImageCreateInfoFUCHSIA();
+    void initialize(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferCollectionImageCreateInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCollectionImageCreateInfoFUCHSIA* ptr() { return reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(this); }
+    VkBufferCollectionImageCreateInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA const*>(this);
+    }
+};
+struct BufferCollectionConstraintsInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t minBufferCount;
+    uint32_t maxBufferCount;
+    uint32_t minBufferCountForCamping;
+    uint32_t minBufferCountForDedicatedSlack;
+    uint32_t minBufferCountForSharedSlack;
+
+    BufferCollectionConstraintsInfoFUCHSIA(const VkBufferCollectionConstraintsInfoFUCHSIA* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BufferCollectionConstraintsInfoFUCHSIA(const BufferCollectionConstraintsInfoFUCHSIA& copy_src);
+    BufferCollectionConstraintsInfoFUCHSIA& operator=(const BufferCollectionConstraintsInfoFUCHSIA& copy_src);
+    BufferCollectionConstraintsInfoFUCHSIA();
+    ~BufferCollectionConstraintsInfoFUCHSIA();
+    void initialize(const VkBufferCollectionConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferCollectionConstraintsInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCollectionConstraintsInfoFUCHSIA* ptr() { return reinterpret_cast<VkBufferCollectionConstraintsInfoFUCHSIA*>(this); }
+    VkBufferCollectionConstraintsInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkBufferCollectionConstraintsInfoFUCHSIA const*>(this);
+    }
+};
+struct BufferConstraintsInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    BufferCreateInfo createInfo;
+    VkFormatFeatureFlags requiredFormatFeatures;
+    BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints;
+
+    BufferConstraintsInfoFUCHSIA(const VkBufferConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    BufferConstraintsInfoFUCHSIA(const BufferConstraintsInfoFUCHSIA& copy_src);
+    BufferConstraintsInfoFUCHSIA& operator=(const BufferConstraintsInfoFUCHSIA& copy_src);
+    BufferConstraintsInfoFUCHSIA();
+    ~BufferConstraintsInfoFUCHSIA();
+    void initialize(const VkBufferConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferConstraintsInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferConstraintsInfoFUCHSIA* ptr() { return reinterpret_cast<VkBufferConstraintsInfoFUCHSIA*>(this); }
+    VkBufferConstraintsInfoFUCHSIA const* ptr() const { return reinterpret_cast<VkBufferConstraintsInfoFUCHSIA const*>(this); }
+};
+struct BufferCollectionBufferCreateInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferCollectionFUCHSIA collection;
+    uint32_t index;
+
+    BufferCollectionBufferCreateInfoFUCHSIA(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    BufferCollectionBufferCreateInfoFUCHSIA(const BufferCollectionBufferCreateInfoFUCHSIA& copy_src);
+    BufferCollectionBufferCreateInfoFUCHSIA& operator=(const BufferCollectionBufferCreateInfoFUCHSIA& copy_src);
+    BufferCollectionBufferCreateInfoFUCHSIA();
+    ~BufferCollectionBufferCreateInfoFUCHSIA();
+    void initialize(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferCollectionBufferCreateInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCollectionBufferCreateInfoFUCHSIA* ptr() { return reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(this); }
+    VkBufferCollectionBufferCreateInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA const*>(this);
+    }
+};
+struct SysmemColorSpaceFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t colorSpace;
+
+    SysmemColorSpaceFUCHSIA(const VkSysmemColorSpaceFUCHSIA* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SysmemColorSpaceFUCHSIA(const SysmemColorSpaceFUCHSIA& copy_src);
+    SysmemColorSpaceFUCHSIA& operator=(const SysmemColorSpaceFUCHSIA& copy_src);
+    SysmemColorSpaceFUCHSIA();
+    ~SysmemColorSpaceFUCHSIA();
+    void initialize(const VkSysmemColorSpaceFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SysmemColorSpaceFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkSysmemColorSpaceFUCHSIA* ptr() { return reinterpret_cast<VkSysmemColorSpaceFUCHSIA*>(this); }
+    VkSysmemColorSpaceFUCHSIA const* ptr() const { return reinterpret_cast<VkSysmemColorSpaceFUCHSIA const*>(this); }
+};
+struct BufferCollectionPropertiesFUCHSIA {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryTypeBits;
+    uint32_t bufferCount;
+    uint32_t createInfoIndex;
+    uint64_t sysmemPixelFormat;
+    VkFormatFeatureFlags formatFeatures;
+    SysmemColorSpaceFUCHSIA sysmemColorSpaceIndex;
+    VkComponentMapping samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion suggestedYcbcrModel;
+    VkSamplerYcbcrRange suggestedYcbcrRange;
+    VkChromaLocation suggestedXChromaOffset;
+    VkChromaLocation suggestedYChromaOffset;
+
+    BufferCollectionPropertiesFUCHSIA(const VkBufferCollectionPropertiesFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    BufferCollectionPropertiesFUCHSIA(const BufferCollectionPropertiesFUCHSIA& copy_src);
+    BufferCollectionPropertiesFUCHSIA& operator=(const BufferCollectionPropertiesFUCHSIA& copy_src);
+    BufferCollectionPropertiesFUCHSIA();
+    ~BufferCollectionPropertiesFUCHSIA();
+    void initialize(const VkBufferCollectionPropertiesFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BufferCollectionPropertiesFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCollectionPropertiesFUCHSIA* ptr() { return reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA*>(this); }
+    VkBufferCollectionPropertiesFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA const*>(this);
+    }
+};
+struct ImageFormatConstraintsInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    ImageCreateInfo imageCreateInfo;
+    VkFormatFeatureFlags requiredFormatFeatures;
+    VkImageFormatConstraintsFlagsFUCHSIA flags;
+    uint64_t sysmemPixelFormat;
+    uint32_t colorSpaceCount;
+    SysmemColorSpaceFUCHSIA* pColorSpaces{};
+
+    ImageFormatConstraintsInfoFUCHSIA(const VkImageFormatConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    ImageFormatConstraintsInfoFUCHSIA(const ImageFormatConstraintsInfoFUCHSIA& copy_src);
+    ImageFormatConstraintsInfoFUCHSIA& operator=(const ImageFormatConstraintsInfoFUCHSIA& copy_src);
+    ImageFormatConstraintsInfoFUCHSIA();
+    ~ImageFormatConstraintsInfoFUCHSIA();
+    void initialize(const VkImageFormatConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageFormatConstraintsInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkImageFormatConstraintsInfoFUCHSIA* ptr() { return reinterpret_cast<VkImageFormatConstraintsInfoFUCHSIA*>(this); }
+    VkImageFormatConstraintsInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkImageFormatConstraintsInfoFUCHSIA const*>(this);
+    }
+};
+struct ImageConstraintsInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t formatConstraintsCount;
+    ImageFormatConstraintsInfoFUCHSIA* pFormatConstraints{};
+    BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints;
+    VkImageConstraintsInfoFlagsFUCHSIA flags;
+
+    ImageConstraintsInfoFUCHSIA(const VkImageConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    ImageConstraintsInfoFUCHSIA(const ImageConstraintsInfoFUCHSIA& copy_src);
+    ImageConstraintsInfoFUCHSIA& operator=(const ImageConstraintsInfoFUCHSIA& copy_src);
+    ImageConstraintsInfoFUCHSIA();
+    ~ImageConstraintsInfoFUCHSIA();
+    void initialize(const VkImageConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageConstraintsInfoFUCHSIA* 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 SubpassShadingPipelineCreateInfoHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    VkRenderPass renderPass;
+    uint32_t subpass;
+
+    SubpassShadingPipelineCreateInfoHUAWEI(const VkSubpassShadingPipelineCreateInfoHUAWEI* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SubpassShadingPipelineCreateInfoHUAWEI(const SubpassShadingPipelineCreateInfoHUAWEI& copy_src);
+    SubpassShadingPipelineCreateInfoHUAWEI& operator=(const SubpassShadingPipelineCreateInfoHUAWEI& copy_src);
+    SubpassShadingPipelineCreateInfoHUAWEI();
+    ~SubpassShadingPipelineCreateInfoHUAWEI();
+    void initialize(const VkSubpassShadingPipelineCreateInfoHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubpassShadingPipelineCreateInfoHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassShadingPipelineCreateInfoHUAWEI* ptr() { return reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(this); }
+    VkSubpassShadingPipelineCreateInfoHUAWEI const* ptr() const {
+        return reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI const*>(this);
+    }
+};
+struct PhysicalDeviceSubpassShadingFeaturesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 subpassShading;
+
+    PhysicalDeviceSubpassShadingFeaturesHUAWEI(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSubpassShadingFeaturesHUAWEI(const PhysicalDeviceSubpassShadingFeaturesHUAWEI& copy_src);
+    PhysicalDeviceSubpassShadingFeaturesHUAWEI& operator=(const PhysicalDeviceSubpassShadingFeaturesHUAWEI& copy_src);
+    PhysicalDeviceSubpassShadingFeaturesHUAWEI();
+    ~PhysicalDeviceSubpassShadingFeaturesHUAWEI();
+    void initialize(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSubpassShadingFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const*>(this);
+    }
+};
+struct PhysicalDeviceSubpassShadingPropertiesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxSubpassShadingWorkgroupSizeAspectRatio;
+
+    PhysicalDeviceSubpassShadingPropertiesHUAWEI(const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSubpassShadingPropertiesHUAWEI(const PhysicalDeviceSubpassShadingPropertiesHUAWEI& copy_src);
+    PhysicalDeviceSubpassShadingPropertiesHUAWEI& operator=(const PhysicalDeviceSubpassShadingPropertiesHUAWEI& copy_src);
+    PhysicalDeviceSubpassShadingPropertiesHUAWEI();
+    ~PhysicalDeviceSubpassShadingPropertiesHUAWEI();
+    void initialize(const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSubpassShadingPropertiesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const*>(this);
+    }
+};
+struct PhysicalDeviceInvocationMaskFeaturesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 invocationMask;
+
+    PhysicalDeviceInvocationMaskFeaturesHUAWEI(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceInvocationMaskFeaturesHUAWEI(const PhysicalDeviceInvocationMaskFeaturesHUAWEI& copy_src);
+    PhysicalDeviceInvocationMaskFeaturesHUAWEI& operator=(const PhysicalDeviceInvocationMaskFeaturesHUAWEI& copy_src);
+    PhysicalDeviceInvocationMaskFeaturesHUAWEI();
+    ~PhysicalDeviceInvocationMaskFeaturesHUAWEI();
+    void initialize(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceInvocationMaskFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const*>(this);
+    }
+};
+struct MemoryGetRemoteAddressInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    MemoryGetRemoteAddressInfoNV(const VkMemoryGetRemoteAddressInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    MemoryGetRemoteAddressInfoNV(const MemoryGetRemoteAddressInfoNV& copy_src);
+    MemoryGetRemoteAddressInfoNV& operator=(const MemoryGetRemoteAddressInfoNV& copy_src);
+    MemoryGetRemoteAddressInfoNV();
+    ~MemoryGetRemoteAddressInfoNV();
+    void initialize(const VkMemoryGetRemoteAddressInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MemoryGetRemoteAddressInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryGetRemoteAddressInfoNV* ptr() { return reinterpret_cast<VkMemoryGetRemoteAddressInfoNV*>(this); }
+    VkMemoryGetRemoteAddressInfoNV const* ptr() const { return reinterpret_cast<VkMemoryGetRemoteAddressInfoNV const*>(this); }
+};
+struct PhysicalDeviceExternalMemoryRDMAFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 externalMemoryRDMA;
+
+    PhysicalDeviceExternalMemoryRDMAFeaturesNV(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExternalMemoryRDMAFeaturesNV(const PhysicalDeviceExternalMemoryRDMAFeaturesNV& copy_src);
+    PhysicalDeviceExternalMemoryRDMAFeaturesNV& operator=(const PhysicalDeviceExternalMemoryRDMAFeaturesNV& copy_src);
+    PhysicalDeviceExternalMemoryRDMAFeaturesNV();
+    ~PhysicalDeviceExternalMemoryRDMAFeaturesNV();
+    void initialize(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExternalMemoryRDMAFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const*>(this);
+    }
+};
+struct PipelinePropertiesIdentifierEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint8_t pipelineIdentifier[VK_UUID_SIZE];
+
+    PipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    PipelinePropertiesIdentifierEXT(const PipelinePropertiesIdentifierEXT& copy_src);
+    PipelinePropertiesIdentifierEXT& operator=(const PipelinePropertiesIdentifierEXT& copy_src);
+    PipelinePropertiesIdentifierEXT();
+    ~PipelinePropertiesIdentifierEXT();
+    void initialize(const VkPipelinePropertiesIdentifierEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelinePropertiesIdentifierEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelinePropertiesIdentifierEXT* ptr() { return reinterpret_cast<VkPipelinePropertiesIdentifierEXT*>(this); }
+    VkPipelinePropertiesIdentifierEXT const* ptr() const {
+        return reinterpret_cast<VkPipelinePropertiesIdentifierEXT const*>(this);
+    }
+};
+struct PhysicalDevicePipelinePropertiesFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelinePropertiesIdentifier;
+
+    PhysicalDevicePipelinePropertiesFeaturesEXT(const VkPhysicalDevicePipelinePropertiesFeaturesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePipelinePropertiesFeaturesEXT(const PhysicalDevicePipelinePropertiesFeaturesEXT& copy_src);
+    PhysicalDevicePipelinePropertiesFeaturesEXT& operator=(const PhysicalDevicePipelinePropertiesFeaturesEXT& copy_src);
+    PhysicalDevicePipelinePropertiesFeaturesEXT();
+    ~PhysicalDevicePipelinePropertiesFeaturesEXT();
+    void initialize(const VkPhysicalDevicePipelinePropertiesFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePipelinePropertiesFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceFrameBoundaryFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 frameBoundary;
+
+    PhysicalDeviceFrameBoundaryFeaturesEXT(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFrameBoundaryFeaturesEXT(const PhysicalDeviceFrameBoundaryFeaturesEXT& copy_src);
+    PhysicalDeviceFrameBoundaryFeaturesEXT& operator=(const PhysicalDeviceFrameBoundaryFeaturesEXT& copy_src);
+    PhysicalDeviceFrameBoundaryFeaturesEXT();
+    ~PhysicalDeviceFrameBoundaryFeaturesEXT();
+    void initialize(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFrameBoundaryFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFrameBoundaryFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(this); }
+    VkPhysicalDeviceFrameBoundaryFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFrameBoundaryFeaturesEXT const*>(this);
+    }
+};
+struct FrameBoundaryEXT {
+    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{};
+
+    FrameBoundaryEXT(const VkFrameBoundaryEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    FrameBoundaryEXT(const FrameBoundaryEXT& copy_src);
+    FrameBoundaryEXT& operator=(const FrameBoundaryEXT& copy_src);
+    FrameBoundaryEXT();
+    ~FrameBoundaryEXT();
+    void initialize(const VkFrameBoundaryEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const FrameBoundaryEXT* copy_src, PNextCopyState* copy_state = {});
+    VkFrameBoundaryEXT* ptr() { return reinterpret_cast<VkFrameBoundaryEXT*>(this); }
+    VkFrameBoundaryEXT const* ptr() const { return reinterpret_cast<VkFrameBoundaryEXT const*>(this); }
+};
+struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 multisampledRenderToSingleSampled;
+
+    PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+        const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+        const PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& copy_src);
+    PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& operator=(
+        const PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& copy_src);
+    PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT();
+    ~PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const*>(this);
+    }
+};
+struct SubpassResolvePerformanceQueryEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 optimal;
+
+    SubpassResolvePerformanceQueryEXT(const VkSubpassResolvePerformanceQueryEXT* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    SubpassResolvePerformanceQueryEXT(const SubpassResolvePerformanceQueryEXT& copy_src);
+    SubpassResolvePerformanceQueryEXT& operator=(const SubpassResolvePerformanceQueryEXT& copy_src);
+    SubpassResolvePerformanceQueryEXT();
+    ~SubpassResolvePerformanceQueryEXT();
+    void initialize(const VkSubpassResolvePerformanceQueryEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubpassResolvePerformanceQueryEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassResolvePerformanceQueryEXT* ptr() { return reinterpret_cast<VkSubpassResolvePerformanceQueryEXT*>(this); }
+    VkSubpassResolvePerformanceQueryEXT const* ptr() const {
+        return reinterpret_cast<VkSubpassResolvePerformanceQueryEXT const*>(this);
+    }
+};
+struct MultisampledRenderToSingleSampledInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 multisampledRenderToSingleSampledEnable;
+    VkSampleCountFlagBits rasterizationSamples;
+
+    MultisampledRenderToSingleSampledInfoEXT(const VkMultisampledRenderToSingleSampledInfoEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MultisampledRenderToSingleSampledInfoEXT(const MultisampledRenderToSingleSampledInfoEXT& copy_src);
+    MultisampledRenderToSingleSampledInfoEXT& operator=(const MultisampledRenderToSingleSampledInfoEXT& copy_src);
+    MultisampledRenderToSingleSampledInfoEXT();
+    ~MultisampledRenderToSingleSampledInfoEXT();
+    void initialize(const VkMultisampledRenderToSingleSampledInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MultisampledRenderToSingleSampledInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMultisampledRenderToSingleSampledInfoEXT* ptr() {
+        return reinterpret_cast<VkMultisampledRenderToSingleSampledInfoEXT*>(this);
+    }
+    VkMultisampledRenderToSingleSampledInfoEXT const* ptr() const {
+        return reinterpret_cast<VkMultisampledRenderToSingleSampledInfoEXT const*>(this);
+    }
+};
+struct PhysicalDeviceExtendedDynamicState2FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 extendedDynamicState2;
+    VkBool32 extendedDynamicState2LogicOp;
+    VkBool32 extendedDynamicState2PatchControlPoints;
+
+    PhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExtendedDynamicState2FeaturesEXT(const PhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src);
+    PhysicalDeviceExtendedDynamicState2FeaturesEXT& operator=(const PhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src);
+    PhysicalDeviceExtendedDynamicState2FeaturesEXT();
+    ~PhysicalDeviceExtendedDynamicState2FeaturesEXT();
+    void initialize(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExtendedDynamicState2FeaturesEXT* 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 ScreenSurfaceCreateInfoQNX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkScreenSurfaceCreateFlagsQNX flags;
+    struct _screen_context* context{};
+    struct _screen_window* window{};
+
+    ScreenSurfaceCreateInfoQNX(const VkScreenSurfaceCreateInfoQNX* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    ScreenSurfaceCreateInfoQNX(const ScreenSurfaceCreateInfoQNX& copy_src);
+    ScreenSurfaceCreateInfoQNX& operator=(const ScreenSurfaceCreateInfoQNX& copy_src);
+    ScreenSurfaceCreateInfoQNX();
+    ~ScreenSurfaceCreateInfoQNX();
+    void initialize(const VkScreenSurfaceCreateInfoQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ScreenSurfaceCreateInfoQNX* 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 PhysicalDeviceColorWriteEnableFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 colorWriteEnable;
+
+    PhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceColorWriteEnableFeaturesEXT(const PhysicalDeviceColorWriteEnableFeaturesEXT& copy_src);
+    PhysicalDeviceColorWriteEnableFeaturesEXT& operator=(const PhysicalDeviceColorWriteEnableFeaturesEXT& copy_src);
+    PhysicalDeviceColorWriteEnableFeaturesEXT();
+    ~PhysicalDeviceColorWriteEnableFeaturesEXT();
+    void initialize(const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceColorWriteEnableFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceColorWriteEnableFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceColorWriteEnableFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT const*>(this);
+    }
+};
+struct PipelineColorWriteCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t attachmentCount;
+    const VkBool32* pColorWriteEnables{};
+
+    PipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    PipelineColorWriteCreateInfoEXT(const PipelineColorWriteCreateInfoEXT& copy_src);
+    PipelineColorWriteCreateInfoEXT& operator=(const PipelineColorWriteCreateInfoEXT& copy_src);
+    PipelineColorWriteCreateInfoEXT();
+    ~PipelineColorWriteCreateInfoEXT();
+    void initialize(const VkPipelineColorWriteCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineColorWriteCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineColorWriteCreateInfoEXT* ptr() { return reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(this); }
+    VkPipelineColorWriteCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineColorWriteCreateInfoEXT const*>(this);
+    }
+};
+struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 primitivesGeneratedQuery;
+    VkBool32 primitivesGeneratedQueryWithRasterizerDiscard;
+    VkBool32 primitivesGeneratedQueryWithNonZeroStreams;
+
+    PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(const PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& copy_src);
+    PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& operator=(const PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& copy_src);
+    PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT();
+    ~PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT();
+    void initialize(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceImageViewMinLodFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 minLod;
+
+    PhysicalDeviceImageViewMinLodFeaturesEXT(const VkPhysicalDeviceImageViewMinLodFeaturesEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceImageViewMinLodFeaturesEXT(const PhysicalDeviceImageViewMinLodFeaturesEXT& copy_src);
+    PhysicalDeviceImageViewMinLodFeaturesEXT& operator=(const PhysicalDeviceImageViewMinLodFeaturesEXT& copy_src);
+    PhysicalDeviceImageViewMinLodFeaturesEXT();
+    ~PhysicalDeviceImageViewMinLodFeaturesEXT();
+    void initialize(const VkPhysicalDeviceImageViewMinLodFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageViewMinLodFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT const*>(this);
+    }
+};
+struct ImageViewMinLodCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    float minLod;
+
+    ImageViewMinLodCreateInfoEXT(const VkImageViewMinLodCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    ImageViewMinLodCreateInfoEXT(const ImageViewMinLodCreateInfoEXT& copy_src);
+    ImageViewMinLodCreateInfoEXT& operator=(const ImageViewMinLodCreateInfoEXT& copy_src);
+    ImageViewMinLodCreateInfoEXT();
+    ~ImageViewMinLodCreateInfoEXT();
+    void initialize(const VkImageViewMinLodCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageViewMinLodCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewMinLodCreateInfoEXT* ptr() { return reinterpret_cast<VkImageViewMinLodCreateInfoEXT*>(this); }
+    VkImageViewMinLodCreateInfoEXT const* ptr() const { return reinterpret_cast<VkImageViewMinLodCreateInfoEXT const*>(this); }
+};
+struct PhysicalDeviceMultiDrawFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 multiDraw;
+
+    PhysicalDeviceMultiDrawFeaturesEXT(const VkPhysicalDeviceMultiDrawFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    PhysicalDeviceMultiDrawFeaturesEXT(const PhysicalDeviceMultiDrawFeaturesEXT& copy_src);
+    PhysicalDeviceMultiDrawFeaturesEXT& operator=(const PhysicalDeviceMultiDrawFeaturesEXT& copy_src);
+    PhysicalDeviceMultiDrawFeaturesEXT();
+    ~PhysicalDeviceMultiDrawFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMultiDrawFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMultiDrawFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiDrawFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(this); }
+    VkPhysicalDeviceMultiDrawFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceMultiDrawPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxMultiDrawCount;
+
+    PhysicalDeviceMultiDrawPropertiesEXT(const VkPhysicalDeviceMultiDrawPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDeviceMultiDrawPropertiesEXT(const PhysicalDeviceMultiDrawPropertiesEXT& copy_src);
+    PhysicalDeviceMultiDrawPropertiesEXT& operator=(const PhysicalDeviceMultiDrawPropertiesEXT& copy_src);
+    PhysicalDeviceMultiDrawPropertiesEXT();
+    ~PhysicalDeviceMultiDrawPropertiesEXT();
+    void initialize(const VkPhysicalDeviceMultiDrawPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMultiDrawPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiDrawPropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(this); }
+    VkPhysicalDeviceMultiDrawPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceImage2DViewOf3DFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 image2DViewOf3D;
+    VkBool32 sampler2DViewOf3D;
+
+    PhysicalDeviceImage2DViewOf3DFeaturesEXT(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceImage2DViewOf3DFeaturesEXT(const PhysicalDeviceImage2DViewOf3DFeaturesEXT& copy_src);
+    PhysicalDeviceImage2DViewOf3DFeaturesEXT& operator=(const PhysicalDeviceImage2DViewOf3DFeaturesEXT& copy_src);
+    PhysicalDeviceImage2DViewOf3DFeaturesEXT();
+    ~PhysicalDeviceImage2DViewOf3DFeaturesEXT();
+    void initialize(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImage2DViewOf3DFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceShaderTileImageFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderTileImageColorReadAccess;
+    VkBool32 shaderTileImageDepthReadAccess;
+    VkBool32 shaderTileImageStencilReadAccess;
+
+    PhysicalDeviceShaderTileImageFeaturesEXT(const VkPhysicalDeviceShaderTileImageFeaturesEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderTileImageFeaturesEXT(const PhysicalDeviceShaderTileImageFeaturesEXT& copy_src);
+    PhysicalDeviceShaderTileImageFeaturesEXT& operator=(const PhysicalDeviceShaderTileImageFeaturesEXT& copy_src);
+    PhysicalDeviceShaderTileImageFeaturesEXT();
+    ~PhysicalDeviceShaderTileImageFeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderTileImageFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderTileImageFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderTileImageFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderTileImageFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceShaderTileImagePropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderTileImageCoherentReadAccelerated;
+    VkBool32 shaderTileImageReadSampleFromPixelRateInvocation;
+    VkBool32 shaderTileImageReadFromHelperInvocation;
+
+    PhysicalDeviceShaderTileImagePropertiesEXT(const VkPhysicalDeviceShaderTileImagePropertiesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderTileImagePropertiesEXT(const PhysicalDeviceShaderTileImagePropertiesEXT& copy_src);
+    PhysicalDeviceShaderTileImagePropertiesEXT& operator=(const PhysicalDeviceShaderTileImagePropertiesEXT& copy_src);
+    PhysicalDeviceShaderTileImagePropertiesEXT();
+    ~PhysicalDeviceShaderTileImagePropertiesEXT();
+    void initialize(const VkPhysicalDeviceShaderTileImagePropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderTileImagePropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderTileImagePropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderTileImagePropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderTileImagePropertiesEXT const*>(this);
+    }
+};
+union DeviceOrHostAddressKHR {
+    VkDeviceAddress deviceAddress;
+    void* hostAddress{};
+
+    DeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* in_struct, PNextCopyState* copy_state = {});
+    DeviceOrHostAddressKHR(const DeviceOrHostAddressKHR& copy_src);
+    DeviceOrHostAddressKHR& operator=(const DeviceOrHostAddressKHR& copy_src);
+    DeviceOrHostAddressKHR();
+    ~DeviceOrHostAddressKHR();
+    void initialize(const VkDeviceOrHostAddressKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceOrHostAddressKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceOrHostAddressKHR* ptr() { return reinterpret_cast<VkDeviceOrHostAddressKHR*>(this); }
+    VkDeviceOrHostAddressKHR const* ptr() const { return reinterpret_cast<VkDeviceOrHostAddressKHR const*>(this); }
+};
+struct MicromapBuildInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMicromapTypeEXT type;
+    VkBuildMicromapFlagsEXT flags;
+    VkBuildMicromapModeEXT mode;
+    VkMicromapEXT dstMicromap;
+    uint32_t usageCountsCount;
+    const VkMicromapUsageEXT* pUsageCounts{};
+    const VkMicromapUsageEXT* const* ppUsageCounts{};
+    DeviceOrHostAddressConstKHR data;
+    DeviceOrHostAddressKHR scratchData;
+    DeviceOrHostAddressConstKHR triangleArray;
+    VkDeviceSize triangleArrayStride;
+
+    MicromapBuildInfoEXT(const VkMicromapBuildInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MicromapBuildInfoEXT(const MicromapBuildInfoEXT& copy_src);
+    MicromapBuildInfoEXT& operator=(const MicromapBuildInfoEXT& copy_src);
+    MicromapBuildInfoEXT();
+    ~MicromapBuildInfoEXT();
+    void initialize(const VkMicromapBuildInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MicromapBuildInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMicromapBuildInfoEXT* ptr() { return reinterpret_cast<VkMicromapBuildInfoEXT*>(this); }
+    VkMicromapBuildInfoEXT const* ptr() const { return reinterpret_cast<VkMicromapBuildInfoEXT const*>(this); }
+};
+struct MicromapCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMicromapCreateFlagsEXT createFlags;
+    VkBuffer buffer;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+    VkMicromapTypeEXT type;
+    VkDeviceAddress deviceAddress;
+
+    MicromapCreateInfoEXT(const VkMicromapCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MicromapCreateInfoEXT(const MicromapCreateInfoEXT& copy_src);
+    MicromapCreateInfoEXT& operator=(const MicromapCreateInfoEXT& copy_src);
+    MicromapCreateInfoEXT();
+    ~MicromapCreateInfoEXT();
+    void initialize(const VkMicromapCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MicromapCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMicromapCreateInfoEXT* ptr() { return reinterpret_cast<VkMicromapCreateInfoEXT*>(this); }
+    VkMicromapCreateInfoEXT const* ptr() const { return reinterpret_cast<VkMicromapCreateInfoEXT const*>(this); }
+};
+struct PhysicalDeviceOpacityMicromapFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 micromap;
+    VkBool32 micromapCaptureReplay;
+    VkBool32 micromapHostCommands;
+
+    PhysicalDeviceOpacityMicromapFeaturesEXT(const VkPhysicalDeviceOpacityMicromapFeaturesEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceOpacityMicromapFeaturesEXT(const PhysicalDeviceOpacityMicromapFeaturesEXT& copy_src);
+    PhysicalDeviceOpacityMicromapFeaturesEXT& operator=(const PhysicalDeviceOpacityMicromapFeaturesEXT& copy_src);
+    PhysicalDeviceOpacityMicromapFeaturesEXT();
+    ~PhysicalDeviceOpacityMicromapFeaturesEXT();
+    void initialize(const VkPhysicalDeviceOpacityMicromapFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceOpacityMicromapFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceOpacityMicromapFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceOpacityMicromapPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxOpacity2StateSubdivisionLevel;
+    uint32_t maxOpacity4StateSubdivisionLevel;
+
+    PhysicalDeviceOpacityMicromapPropertiesEXT(const VkPhysicalDeviceOpacityMicromapPropertiesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceOpacityMicromapPropertiesEXT(const PhysicalDeviceOpacityMicromapPropertiesEXT& copy_src);
+    PhysicalDeviceOpacityMicromapPropertiesEXT& operator=(const PhysicalDeviceOpacityMicromapPropertiesEXT& copy_src);
+    PhysicalDeviceOpacityMicromapPropertiesEXT();
+    ~PhysicalDeviceOpacityMicromapPropertiesEXT();
+    void initialize(const VkPhysicalDeviceOpacityMicromapPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceOpacityMicromapPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceOpacityMicromapPropertiesEXT const*>(this);
+    }
+};
+struct MicromapVersionInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    const uint8_t* pVersionData{};
+
+    MicromapVersionInfoEXT(const VkMicromapVersionInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MicromapVersionInfoEXT(const MicromapVersionInfoEXT& copy_src);
+    MicromapVersionInfoEXT& operator=(const MicromapVersionInfoEXT& copy_src);
+    MicromapVersionInfoEXT();
+    ~MicromapVersionInfoEXT();
+    void initialize(const VkMicromapVersionInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MicromapVersionInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMicromapVersionInfoEXT* ptr() { return reinterpret_cast<VkMicromapVersionInfoEXT*>(this); }
+    VkMicromapVersionInfoEXT const* ptr() const { return reinterpret_cast<VkMicromapVersionInfoEXT const*>(this); }
+};
+struct CopyMicromapToMemoryInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMicromapEXT src;
+    DeviceOrHostAddressKHR dst;
+    VkCopyMicromapModeEXT mode;
+
+    CopyMicromapToMemoryInfoEXT(const VkCopyMicromapToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    CopyMicromapToMemoryInfoEXT(const CopyMicromapToMemoryInfoEXT& copy_src);
+    CopyMicromapToMemoryInfoEXT& operator=(const CopyMicromapToMemoryInfoEXT& copy_src);
+    CopyMicromapToMemoryInfoEXT();
+    ~CopyMicromapToMemoryInfoEXT();
+    void initialize(const VkCopyMicromapToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyMicromapToMemoryInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyMicromapToMemoryInfoEXT* ptr() { return reinterpret_cast<VkCopyMicromapToMemoryInfoEXT*>(this); }
+    VkCopyMicromapToMemoryInfoEXT const* ptr() const { return reinterpret_cast<VkCopyMicromapToMemoryInfoEXT const*>(this); }
+};
+struct CopyMemoryToMicromapInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    DeviceOrHostAddressConstKHR src;
+    VkMicromapEXT dst;
+    VkCopyMicromapModeEXT mode;
+
+    CopyMemoryToMicromapInfoEXT(const VkCopyMemoryToMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    CopyMemoryToMicromapInfoEXT(const CopyMemoryToMicromapInfoEXT& copy_src);
+    CopyMemoryToMicromapInfoEXT& operator=(const CopyMemoryToMicromapInfoEXT& copy_src);
+    CopyMemoryToMicromapInfoEXT();
+    ~CopyMemoryToMicromapInfoEXT();
+    void initialize(const VkCopyMemoryToMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyMemoryToMicromapInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyMemoryToMicromapInfoEXT* ptr() { return reinterpret_cast<VkCopyMemoryToMicromapInfoEXT*>(this); }
+    VkCopyMemoryToMicromapInfoEXT const* ptr() const { return reinterpret_cast<VkCopyMemoryToMicromapInfoEXT const*>(this); }
+};
+struct CopyMicromapInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMicromapEXT src;
+    VkMicromapEXT dst;
+    VkCopyMicromapModeEXT mode;
+
+    CopyMicromapInfoEXT(const VkCopyMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CopyMicromapInfoEXT(const CopyMicromapInfoEXT& copy_src);
+    CopyMicromapInfoEXT& operator=(const CopyMicromapInfoEXT& copy_src);
+    CopyMicromapInfoEXT();
+    ~CopyMicromapInfoEXT();
+    void initialize(const VkCopyMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyMicromapInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyMicromapInfoEXT* ptr() { return reinterpret_cast<VkCopyMicromapInfoEXT*>(this); }
+    VkCopyMicromapInfoEXT const* ptr() const { return reinterpret_cast<VkCopyMicromapInfoEXT const*>(this); }
+};
+struct MicromapBuildSizesInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize micromapSize;
+    VkDeviceSize buildScratchSize;
+    VkBool32 discardable;
+
+    MicromapBuildSizesInfoEXT(const VkMicromapBuildSizesInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    MicromapBuildSizesInfoEXT(const MicromapBuildSizesInfoEXT& copy_src);
+    MicromapBuildSizesInfoEXT& operator=(const MicromapBuildSizesInfoEXT& copy_src);
+    MicromapBuildSizesInfoEXT();
+    ~MicromapBuildSizesInfoEXT();
+    void initialize(const VkMicromapBuildSizesInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MicromapBuildSizesInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMicromapBuildSizesInfoEXT* ptr() { return reinterpret_cast<VkMicromapBuildSizesInfoEXT*>(this); }
+    VkMicromapBuildSizesInfoEXT const* ptr() const { return reinterpret_cast<VkMicromapBuildSizesInfoEXT const*>(this); }
+};
+struct AccelerationStructureTrianglesOpacityMicromapEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkIndexType indexType;
+    DeviceOrHostAddressConstKHR indexBuffer;
+    VkDeviceSize indexStride;
+    uint32_t baseTriangle;
+    uint32_t usageCountsCount;
+    const VkMicromapUsageEXT* pUsageCounts{};
+    const VkMicromapUsageEXT* const* ppUsageCounts{};
+    VkMicromapEXT micromap;
+
+    AccelerationStructureTrianglesOpacityMicromapEXT(const VkAccelerationStructureTrianglesOpacityMicromapEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureTrianglesOpacityMicromapEXT(const AccelerationStructureTrianglesOpacityMicromapEXT& copy_src);
+    AccelerationStructureTrianglesOpacityMicromapEXT& operator=(const AccelerationStructureTrianglesOpacityMicromapEXT& copy_src);
+    AccelerationStructureTrianglesOpacityMicromapEXT();
+    ~AccelerationStructureTrianglesOpacityMicromapEXT();
+    void initialize(const VkAccelerationStructureTrianglesOpacityMicromapEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureTrianglesOpacityMicromapEXT* 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 PhysicalDeviceDisplacementMicromapFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 displacementMicromap;
+
+    PhysicalDeviceDisplacementMicromapFeaturesNV(const VkPhysicalDeviceDisplacementMicromapFeaturesNV* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDisplacementMicromapFeaturesNV(const PhysicalDeviceDisplacementMicromapFeaturesNV& copy_src);
+    PhysicalDeviceDisplacementMicromapFeaturesNV& operator=(const PhysicalDeviceDisplacementMicromapFeaturesNV& copy_src);
+    PhysicalDeviceDisplacementMicromapFeaturesNV();
+    ~PhysicalDeviceDisplacementMicromapFeaturesNV();
+    void initialize(const VkPhysicalDeviceDisplacementMicromapFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDisplacementMicromapFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceDisplacementMicromapPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxDisplacementMicromapSubdivisionLevel;
+
+    PhysicalDeviceDisplacementMicromapPropertiesNV(const VkPhysicalDeviceDisplacementMicromapPropertiesNV* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDisplacementMicromapPropertiesNV(const PhysicalDeviceDisplacementMicromapPropertiesNV& copy_src);
+    PhysicalDeviceDisplacementMicromapPropertiesNV& operator=(const PhysicalDeviceDisplacementMicromapPropertiesNV& copy_src);
+    PhysicalDeviceDisplacementMicromapPropertiesNV();
+    ~PhysicalDeviceDisplacementMicromapPropertiesNV();
+    void initialize(const VkPhysicalDeviceDisplacementMicromapPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDisplacementMicromapPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDisplacementMicromapPropertiesNV const*>(this);
+    }
+};
+struct AccelerationStructureTrianglesDisplacementMicromapNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat displacementBiasAndScaleFormat;
+    VkFormat displacementVectorFormat;
+    DeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer;
+    VkDeviceSize displacementBiasAndScaleStride;
+    DeviceOrHostAddressConstKHR displacementVectorBuffer;
+    VkDeviceSize displacementVectorStride;
+    DeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags;
+    VkDeviceSize displacedMicromapPrimitiveFlagsStride;
+    VkIndexType indexType;
+    DeviceOrHostAddressConstKHR indexBuffer;
+    VkDeviceSize indexStride;
+    uint32_t baseTriangle;
+    uint32_t usageCountsCount;
+    const VkMicromapUsageEXT* pUsageCounts{};
+    const VkMicromapUsageEXT* const* ppUsageCounts{};
+    VkMicromapEXT micromap;
+
+    AccelerationStructureTrianglesDisplacementMicromapNV(const VkAccelerationStructureTrianglesDisplacementMicromapNV* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureTrianglesDisplacementMicromapNV(const AccelerationStructureTrianglesDisplacementMicromapNV& copy_src);
+    AccelerationStructureTrianglesDisplacementMicromapNV& operator=(
+        const AccelerationStructureTrianglesDisplacementMicromapNV& copy_src);
+    AccelerationStructureTrianglesDisplacementMicromapNV();
+    ~AccelerationStructureTrianglesDisplacementMicromapNV();
+    void initialize(const VkAccelerationStructureTrianglesDisplacementMicromapNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureTrianglesDisplacementMicromapNV* 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 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 clustercullingShader;
+    VkBool32 multiviewClusterCullingShader;
+
+    PhysicalDeviceClusterCullingShaderFeaturesHUAWEI(const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceClusterCullingShaderFeaturesHUAWEI(const PhysicalDeviceClusterCullingShaderFeaturesHUAWEI& copy_src);
+    PhysicalDeviceClusterCullingShaderFeaturesHUAWEI& operator=(const PhysicalDeviceClusterCullingShaderFeaturesHUAWEI& copy_src);
+    PhysicalDeviceClusterCullingShaderFeaturesHUAWEI();
+    ~PhysicalDeviceClusterCullingShaderFeaturesHUAWEI();
+    void initialize(const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceClusterCullingShaderFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const*>(this);
+    }
+};
+struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxWorkGroupCount[3];
+    uint32_t maxWorkGroupSize[3];
+    uint32_t maxOutputClusterCount;
+    VkDeviceSize indirectBufferOffsetAlignment;
+
+    PhysicalDeviceClusterCullingShaderPropertiesHUAWEI(const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceClusterCullingShaderPropertiesHUAWEI(const PhysicalDeviceClusterCullingShaderPropertiesHUAWEI& copy_src);
+    PhysicalDeviceClusterCullingShaderPropertiesHUAWEI& operator=(
+        const PhysicalDeviceClusterCullingShaderPropertiesHUAWEI& copy_src);
+    PhysicalDeviceClusterCullingShaderPropertiesHUAWEI();
+    ~PhysicalDeviceClusterCullingShaderPropertiesHUAWEI();
+    void initialize(const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceClusterCullingShaderPropertiesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const*>(this);
+    }
+};
+struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 clusterShadingRate;
+
+    PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(const PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& copy_src);
+    PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& operator=(
+        const PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& copy_src);
+    PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI();
+    ~PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI();
+    void initialize(const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const*>(this);
+    }
+};
+struct PhysicalDeviceBorderColorSwizzleFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 borderColorSwizzle;
+    VkBool32 borderColorSwizzleFromImage;
+
+    PhysicalDeviceBorderColorSwizzleFeaturesEXT(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceBorderColorSwizzleFeaturesEXT(const PhysicalDeviceBorderColorSwizzleFeaturesEXT& copy_src);
+    PhysicalDeviceBorderColorSwizzleFeaturesEXT& operator=(const PhysicalDeviceBorderColorSwizzleFeaturesEXT& copy_src);
+    PhysicalDeviceBorderColorSwizzleFeaturesEXT();
+    ~PhysicalDeviceBorderColorSwizzleFeaturesEXT();
+    void initialize(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceBorderColorSwizzleFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const*>(this);
+    }
+};
+struct SamplerBorderColorComponentMappingCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkComponentMapping components;
+    VkBool32 srgb;
+
+    SamplerBorderColorComponentMappingCreateInfoEXT(const VkSamplerBorderColorComponentMappingCreateInfoEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SamplerBorderColorComponentMappingCreateInfoEXT(const SamplerBorderColorComponentMappingCreateInfoEXT& copy_src);
+    SamplerBorderColorComponentMappingCreateInfoEXT& operator=(const SamplerBorderColorComponentMappingCreateInfoEXT& copy_src);
+    SamplerBorderColorComponentMappingCreateInfoEXT();
+    ~SamplerBorderColorComponentMappingCreateInfoEXT();
+    void initialize(const VkSamplerBorderColorComponentMappingCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SamplerBorderColorComponentMappingCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerBorderColorComponentMappingCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(this);
+    }
+    VkSamplerBorderColorComponentMappingCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT const*>(this);
+    }
+};
+struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pageableDeviceLocalMemory;
+
+    PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(const PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& copy_src);
+    PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& operator=(
+        const PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& copy_src);
+    PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT();
+    ~PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT();
+    void initialize(const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceShaderCorePropertiesARM {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t pixelRate;
+    uint32_t texelRate;
+    uint32_t fmaRate;
+
+    PhysicalDeviceShaderCorePropertiesARM(const VkPhysicalDeviceShaderCorePropertiesARM* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDeviceShaderCorePropertiesARM(const PhysicalDeviceShaderCorePropertiesARM& copy_src);
+    PhysicalDeviceShaderCorePropertiesARM& operator=(const PhysicalDeviceShaderCorePropertiesARM& copy_src);
+    PhysicalDeviceShaderCorePropertiesARM();
+    ~PhysicalDeviceShaderCorePropertiesARM();
+    void initialize(const VkPhysicalDeviceShaderCorePropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderCorePropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderCorePropertiesARM* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM*>(this); }
+    VkPhysicalDeviceShaderCorePropertiesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM const*>(this);
+    }
+};
+struct DeviceQueueShaderCoreControlCreateInfoARM {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t shaderCoreCount;
+
+    DeviceQueueShaderCoreControlCreateInfoARM(const VkDeviceQueueShaderCoreControlCreateInfoARM* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DeviceQueueShaderCoreControlCreateInfoARM(const DeviceQueueShaderCoreControlCreateInfoARM& copy_src);
+    DeviceQueueShaderCoreControlCreateInfoARM& operator=(const DeviceQueueShaderCoreControlCreateInfoARM& copy_src);
+    DeviceQueueShaderCoreControlCreateInfoARM();
+    ~DeviceQueueShaderCoreControlCreateInfoARM();
+    void initialize(const VkDeviceQueueShaderCoreControlCreateInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DeviceQueueShaderCoreControlCreateInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceQueueShaderCoreControlCreateInfoARM* ptr() {
+        return reinterpret_cast<VkDeviceQueueShaderCoreControlCreateInfoARM*>(this);
+    }
+    VkDeviceQueueShaderCoreControlCreateInfoARM const* ptr() const {
+        return reinterpret_cast<VkDeviceQueueShaderCoreControlCreateInfoARM const*>(this);
+    }
+};
+struct PhysicalDeviceSchedulingControlsFeaturesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 schedulingControls;
+
+    PhysicalDeviceSchedulingControlsFeaturesARM(const VkPhysicalDeviceSchedulingControlsFeaturesARM* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSchedulingControlsFeaturesARM(const PhysicalDeviceSchedulingControlsFeaturesARM& copy_src);
+    PhysicalDeviceSchedulingControlsFeaturesARM& operator=(const PhysicalDeviceSchedulingControlsFeaturesARM& copy_src);
+    PhysicalDeviceSchedulingControlsFeaturesARM();
+    ~PhysicalDeviceSchedulingControlsFeaturesARM();
+    void initialize(const VkPhysicalDeviceSchedulingControlsFeaturesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSchedulingControlsFeaturesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSchedulingControlsFeaturesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSchedulingControlsFeaturesARM*>(this);
+    }
+    VkPhysicalDeviceSchedulingControlsFeaturesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSchedulingControlsFeaturesARM const*>(this);
+    }
+};
+struct PhysicalDeviceSchedulingControlsPropertiesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkPhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags;
+
+    PhysicalDeviceSchedulingControlsPropertiesARM(const VkPhysicalDeviceSchedulingControlsPropertiesARM* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSchedulingControlsPropertiesARM(const PhysicalDeviceSchedulingControlsPropertiesARM& copy_src);
+    PhysicalDeviceSchedulingControlsPropertiesARM& operator=(const PhysicalDeviceSchedulingControlsPropertiesARM& copy_src);
+    PhysicalDeviceSchedulingControlsPropertiesARM();
+    ~PhysicalDeviceSchedulingControlsPropertiesARM();
+    void initialize(const VkPhysicalDeviceSchedulingControlsPropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSchedulingControlsPropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSchedulingControlsPropertiesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSchedulingControlsPropertiesARM*>(this);
+    }
+    VkPhysicalDeviceSchedulingControlsPropertiesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSchedulingControlsPropertiesARM const*>(this);
+    }
+};
+struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 imageSlicedViewOf3D;
+
+    PhysicalDeviceImageSlicedViewOf3DFeaturesEXT(const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceImageSlicedViewOf3DFeaturesEXT(const PhysicalDeviceImageSlicedViewOf3DFeaturesEXT& copy_src);
+    PhysicalDeviceImageSlicedViewOf3DFeaturesEXT& operator=(const PhysicalDeviceImageSlicedViewOf3DFeaturesEXT& copy_src);
+    PhysicalDeviceImageSlicedViewOf3DFeaturesEXT();
+    ~PhysicalDeviceImageSlicedViewOf3DFeaturesEXT();
+    void initialize(const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageSlicedViewOf3DFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const*>(this);
+    }
+};
+struct ImageViewSlicedCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t sliceOffset;
+    uint32_t sliceCount;
+
+    ImageViewSlicedCreateInfoEXT(const VkImageViewSlicedCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    ImageViewSlicedCreateInfoEXT(const ImageViewSlicedCreateInfoEXT& copy_src);
+    ImageViewSlicedCreateInfoEXT& operator=(const ImageViewSlicedCreateInfoEXT& copy_src);
+    ImageViewSlicedCreateInfoEXT();
+    ~ImageViewSlicedCreateInfoEXT();
+    void initialize(const VkImageViewSlicedCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageViewSlicedCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewSlicedCreateInfoEXT* ptr() { return reinterpret_cast<VkImageViewSlicedCreateInfoEXT*>(this); }
+    VkImageViewSlicedCreateInfoEXT const* ptr() const { return reinterpret_cast<VkImageViewSlicedCreateInfoEXT const*>(this); }
+};
+struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 descriptorSetHostMapping;
+
+    PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(const PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& copy_src);
+    PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& operator=(
+        const PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& copy_src);
+    PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE();
+    ~PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE();
+    void initialize(const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(this);
+    }
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const*>(this);
+    }
+};
+struct DescriptorSetBindingReferenceVALVE {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorSetLayout descriptorSetLayout;
+    uint32_t binding;
+
+    DescriptorSetBindingReferenceVALVE(const VkDescriptorSetBindingReferenceVALVE* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    DescriptorSetBindingReferenceVALVE(const DescriptorSetBindingReferenceVALVE& copy_src);
+    DescriptorSetBindingReferenceVALVE& operator=(const DescriptorSetBindingReferenceVALVE& copy_src);
+    DescriptorSetBindingReferenceVALVE();
+    ~DescriptorSetBindingReferenceVALVE();
+    void initialize(const VkDescriptorSetBindingReferenceVALVE* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorSetBindingReferenceVALVE* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetBindingReferenceVALVE* ptr() { return reinterpret_cast<VkDescriptorSetBindingReferenceVALVE*>(this); }
+    VkDescriptorSetBindingReferenceVALVE const* ptr() const {
+        return reinterpret_cast<VkDescriptorSetBindingReferenceVALVE const*>(this);
+    }
+};
+struct DescriptorSetLayoutHostMappingInfoVALVE {
+    VkStructureType sType;
+    void* pNext{};
+    size_t descriptorOffset;
+    uint32_t descriptorSize;
+
+    DescriptorSetLayoutHostMappingInfoVALVE(const VkDescriptorSetLayoutHostMappingInfoVALVE* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    DescriptorSetLayoutHostMappingInfoVALVE(const DescriptorSetLayoutHostMappingInfoVALVE& copy_src);
+    DescriptorSetLayoutHostMappingInfoVALVE& operator=(const DescriptorSetLayoutHostMappingInfoVALVE& copy_src);
+    DescriptorSetLayoutHostMappingInfoVALVE();
+    ~DescriptorSetLayoutHostMappingInfoVALVE();
+    void initialize(const VkDescriptorSetLayoutHostMappingInfoVALVE* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DescriptorSetLayoutHostMappingInfoVALVE* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetLayoutHostMappingInfoVALVE* ptr() { return reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE*>(this); }
+    VkDescriptorSetLayoutHostMappingInfoVALVE const* ptr() const {
+        return reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE const*>(this);
+    }
+};
+struct PhysicalDeviceDepthClampZeroOneFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 depthClampZeroOne;
+
+    PhysicalDeviceDepthClampZeroOneFeaturesEXT(const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDepthClampZeroOneFeaturesEXT(const PhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src);
+    PhysicalDeviceDepthClampZeroOneFeaturesEXT& operator=(const PhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src);
+    PhysicalDeviceDepthClampZeroOneFeaturesEXT();
+    ~PhysicalDeviceDepthClampZeroOneFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDepthClampZeroOneFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 nonSeamlessCubeMap;
+
+    PhysicalDeviceNonSeamlessCubeMapFeaturesEXT(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceNonSeamlessCubeMapFeaturesEXT(const PhysicalDeviceNonSeamlessCubeMapFeaturesEXT& copy_src);
+    PhysicalDeviceNonSeamlessCubeMapFeaturesEXT& operator=(const PhysicalDeviceNonSeamlessCubeMapFeaturesEXT& copy_src);
+    PhysicalDeviceNonSeamlessCubeMapFeaturesEXT();
+    ~PhysicalDeviceNonSeamlessCubeMapFeaturesEXT();
+    void initialize(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceNonSeamlessCubeMapFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceRenderPassStripedFeaturesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 renderPassStriped;
+
+    PhysicalDeviceRenderPassStripedFeaturesARM(const VkPhysicalDeviceRenderPassStripedFeaturesARM* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRenderPassStripedFeaturesARM(const PhysicalDeviceRenderPassStripedFeaturesARM& copy_src);
+    PhysicalDeviceRenderPassStripedFeaturesARM& operator=(const PhysicalDeviceRenderPassStripedFeaturesARM& copy_src);
+    PhysicalDeviceRenderPassStripedFeaturesARM();
+    ~PhysicalDeviceRenderPassStripedFeaturesARM();
+    void initialize(const VkPhysicalDeviceRenderPassStripedFeaturesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRenderPassStripedFeaturesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRenderPassStripedFeaturesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRenderPassStripedFeaturesARM*>(this);
+    }
+    VkPhysicalDeviceRenderPassStripedFeaturesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRenderPassStripedFeaturesARM const*>(this);
+    }
+};
+struct PhysicalDeviceRenderPassStripedPropertiesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D renderPassStripeGranularity;
+    uint32_t maxRenderPassStripes;
+
+    PhysicalDeviceRenderPassStripedPropertiesARM(const VkPhysicalDeviceRenderPassStripedPropertiesARM* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRenderPassStripedPropertiesARM(const PhysicalDeviceRenderPassStripedPropertiesARM& copy_src);
+    PhysicalDeviceRenderPassStripedPropertiesARM& operator=(const PhysicalDeviceRenderPassStripedPropertiesARM& copy_src);
+    PhysicalDeviceRenderPassStripedPropertiesARM();
+    ~PhysicalDeviceRenderPassStripedPropertiesARM();
+    void initialize(const VkPhysicalDeviceRenderPassStripedPropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRenderPassStripedPropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRenderPassStripedPropertiesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRenderPassStripedPropertiesARM*>(this);
+    }
+    VkPhysicalDeviceRenderPassStripedPropertiesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRenderPassStripedPropertiesARM const*>(this);
+    }
+};
+struct RenderPassStripeInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRect2D stripeArea;
+
+    RenderPassStripeInfoARM(const VkRenderPassStripeInfoARM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderPassStripeInfoARM(const RenderPassStripeInfoARM& copy_src);
+    RenderPassStripeInfoARM& operator=(const RenderPassStripeInfoARM& copy_src);
+    RenderPassStripeInfoARM();
+    ~RenderPassStripeInfoARM();
+    void initialize(const VkRenderPassStripeInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassStripeInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassStripeInfoARM* ptr() { return reinterpret_cast<VkRenderPassStripeInfoARM*>(this); }
+    VkRenderPassStripeInfoARM const* ptr() const { return reinterpret_cast<VkRenderPassStripeInfoARM const*>(this); }
+};
+struct RenderPassStripeBeginInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stripeInfoCount;
+    RenderPassStripeInfoARM* pStripeInfos{};
+
+    RenderPassStripeBeginInfoARM(const VkRenderPassStripeBeginInfoARM* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    RenderPassStripeBeginInfoARM(const RenderPassStripeBeginInfoARM& copy_src);
+    RenderPassStripeBeginInfoARM& operator=(const RenderPassStripeBeginInfoARM& copy_src);
+    RenderPassStripeBeginInfoARM();
+    ~RenderPassStripeBeginInfoARM();
+    void initialize(const VkRenderPassStripeBeginInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassStripeBeginInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassStripeBeginInfoARM* ptr() { return reinterpret_cast<VkRenderPassStripeBeginInfoARM*>(this); }
+    VkRenderPassStripeBeginInfoARM const* ptr() const { return reinterpret_cast<VkRenderPassStripeBeginInfoARM const*>(this); }
+};
+struct RenderPassStripeSubmitInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stripeSemaphoreInfoCount;
+    SemaphoreSubmitInfo* pStripeSemaphoreInfos{};
+
+    RenderPassStripeSubmitInfoARM(const VkRenderPassStripeSubmitInfoARM* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    RenderPassStripeSubmitInfoARM(const RenderPassStripeSubmitInfoARM& copy_src);
+    RenderPassStripeSubmitInfoARM& operator=(const RenderPassStripeSubmitInfoARM& copy_src);
+    RenderPassStripeSubmitInfoARM();
+    ~RenderPassStripeSubmitInfoARM();
+    void initialize(const VkRenderPassStripeSubmitInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassStripeSubmitInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassStripeSubmitInfoARM* ptr() { return reinterpret_cast<VkRenderPassStripeSubmitInfoARM*>(this); }
+    VkRenderPassStripeSubmitInfoARM const* ptr() const { return reinterpret_cast<VkRenderPassStripeSubmitInfoARM const*>(this); }
+};
+struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentDensityMapOffset;
+
+    PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(const PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src);
+    PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& operator=(
+        const PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src);
+    PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM();
+    ~PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const*>(this);
+    }
+};
+struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D fragmentDensityOffsetGranularity;
+
+    PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(const PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src);
+    PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& operator=(
+        const PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src);
+    PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM();
+    ~PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM();
+    void initialize(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const*>(this);
+    }
+};
+struct SubpassFragmentDensityMapOffsetEndInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t fragmentDensityOffsetCount;
+    const VkOffset2D* pFragmentDensityOffsets{};
+
+    SubpassFragmentDensityMapOffsetEndInfoQCOM(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SubpassFragmentDensityMapOffsetEndInfoQCOM(const SubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src);
+    SubpassFragmentDensityMapOffsetEndInfoQCOM& operator=(const SubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src);
+    SubpassFragmentDensityMapOffsetEndInfoQCOM();
+    ~SubpassFragmentDensityMapOffsetEndInfoQCOM();
+    void initialize(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SubpassFragmentDensityMapOffsetEndInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* ptr() {
+        return reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(this);
+    }
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM const*>(this);
+    }
+};
+struct PhysicalDeviceCopyMemoryIndirectFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 indirectCopy;
+
+    PhysicalDeviceCopyMemoryIndirectFeaturesNV(const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCopyMemoryIndirectFeaturesNV(const PhysicalDeviceCopyMemoryIndirectFeaturesNV& copy_src);
+    PhysicalDeviceCopyMemoryIndirectFeaturesNV& operator=(const PhysicalDeviceCopyMemoryIndirectFeaturesNV& copy_src);
+    PhysicalDeviceCopyMemoryIndirectFeaturesNV();
+    ~PhysicalDeviceCopyMemoryIndirectFeaturesNV();
+    void initialize(const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCopyMemoryIndirectFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceCopyMemoryIndirectPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkQueueFlags supportedQueues;
+
+    PhysicalDeviceCopyMemoryIndirectPropertiesNV(const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCopyMemoryIndirectPropertiesNV(const PhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src);
+    PhysicalDeviceCopyMemoryIndirectPropertiesNV& operator=(const PhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src);
+    PhysicalDeviceCopyMemoryIndirectPropertiesNV();
+    ~PhysicalDeviceCopyMemoryIndirectPropertiesNV();
+    void initialize(const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCopyMemoryIndirectPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const*>(this);
+    }
+};
+struct PhysicalDeviceMemoryDecompressionFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 memoryDecompression;
+
+    PhysicalDeviceMemoryDecompressionFeaturesNV(const VkPhysicalDeviceMemoryDecompressionFeaturesNV* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMemoryDecompressionFeaturesNV(const PhysicalDeviceMemoryDecompressionFeaturesNV& copy_src);
+    PhysicalDeviceMemoryDecompressionFeaturesNV& operator=(const PhysicalDeviceMemoryDecompressionFeaturesNV& copy_src);
+    PhysicalDeviceMemoryDecompressionFeaturesNV();
+    ~PhysicalDeviceMemoryDecompressionFeaturesNV();
+    void initialize(const VkPhysicalDeviceMemoryDecompressionFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMemoryDecompressionFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMemoryDecompressionFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceMemoryDecompressionPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkMemoryDecompressionMethodFlagsNV decompressionMethods;
+    uint64_t maxDecompressionIndirectCount;
+
+    PhysicalDeviceMemoryDecompressionPropertiesNV(const VkPhysicalDeviceMemoryDecompressionPropertiesNV* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMemoryDecompressionPropertiesNV(const PhysicalDeviceMemoryDecompressionPropertiesNV& copy_src);
+    PhysicalDeviceMemoryDecompressionPropertiesNV& operator=(const PhysicalDeviceMemoryDecompressionPropertiesNV& copy_src);
+    PhysicalDeviceMemoryDecompressionPropertiesNV();
+    ~PhysicalDeviceMemoryDecompressionPropertiesNV();
+    void initialize(const VkPhysicalDeviceMemoryDecompressionPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMemoryDecompressionPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMemoryDecompressionPropertiesNV const*>(this);
+    }
+};
+struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 deviceGeneratedCompute;
+    VkBool32 deviceGeneratedComputePipelines;
+    VkBool32 deviceGeneratedComputeCaptureReplay;
+
+    PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(
+        const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(const PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& copy_src);
+    PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& operator=(
+        const PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& copy_src);
+    PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV();
+    ~PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV();
+    void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const*>(this);
+    }
+};
+struct ComputePipelineIndirectBufferInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceAddress deviceAddress;
+    VkDeviceSize size;
+    VkDeviceAddress pipelineDeviceAddressCaptureReplay;
+
+    ComputePipelineIndirectBufferInfoNV(const VkComputePipelineIndirectBufferInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    ComputePipelineIndirectBufferInfoNV(const ComputePipelineIndirectBufferInfoNV& copy_src);
+    ComputePipelineIndirectBufferInfoNV& operator=(const ComputePipelineIndirectBufferInfoNV& copy_src);
+    ComputePipelineIndirectBufferInfoNV();
+    ~ComputePipelineIndirectBufferInfoNV();
+    void initialize(const VkComputePipelineIndirectBufferInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ComputePipelineIndirectBufferInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkComputePipelineIndirectBufferInfoNV* ptr() { return reinterpret_cast<VkComputePipelineIndirectBufferInfoNV*>(this); }
+    VkComputePipelineIndirectBufferInfoNV const* ptr() const {
+        return reinterpret_cast<VkComputePipelineIndirectBufferInfoNV const*>(this);
+    }
+};
+struct PipelineIndirectDeviceAddressInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineBindPoint pipelineBindPoint;
+    VkPipeline pipeline;
+
+    PipelineIndirectDeviceAddressInfoNV(const VkPipelineIndirectDeviceAddressInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    PipelineIndirectDeviceAddressInfoNV(const PipelineIndirectDeviceAddressInfoNV& copy_src);
+    PipelineIndirectDeviceAddressInfoNV& operator=(const PipelineIndirectDeviceAddressInfoNV& copy_src);
+    PipelineIndirectDeviceAddressInfoNV();
+    ~PipelineIndirectDeviceAddressInfoNV();
+    void initialize(const VkPipelineIndirectDeviceAddressInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineIndirectDeviceAddressInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineIndirectDeviceAddressInfoNV* ptr() { return reinterpret_cast<VkPipelineIndirectDeviceAddressInfoNV*>(this); }
+    VkPipelineIndirectDeviceAddressInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineIndirectDeviceAddressInfoNV const*>(this);
+    }
+};
+struct PhysicalDeviceLinearColorAttachmentFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 linearColorAttachment;
+
+    PhysicalDeviceLinearColorAttachmentFeaturesNV(const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceLinearColorAttachmentFeaturesNV(const PhysicalDeviceLinearColorAttachmentFeaturesNV& copy_src);
+    PhysicalDeviceLinearColorAttachmentFeaturesNV& operator=(const PhysicalDeviceLinearColorAttachmentFeaturesNV& copy_src);
+    PhysicalDeviceLinearColorAttachmentFeaturesNV();
+    ~PhysicalDeviceLinearColorAttachmentFeaturesNV();
+    void initialize(const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceLinearColorAttachmentFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 imageCompressionControlSwapchain;
+
+    PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+        const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+        const PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& copy_src);
+    PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& operator=(
+        const PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& copy_src);
+    PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT();
+    ~PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT();
+    void initialize(const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const*>(this);
+    }
+};
+struct ImageViewSampleWeightCreateInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkOffset2D filterCenter;
+    VkExtent2D filterSize;
+    uint32_t numPhases;
+
+    ImageViewSampleWeightCreateInfoQCOM(const VkImageViewSampleWeightCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    ImageViewSampleWeightCreateInfoQCOM(const ImageViewSampleWeightCreateInfoQCOM& copy_src);
+    ImageViewSampleWeightCreateInfoQCOM& operator=(const ImageViewSampleWeightCreateInfoQCOM& copy_src);
+    ImageViewSampleWeightCreateInfoQCOM();
+    ~ImageViewSampleWeightCreateInfoQCOM();
+    void initialize(const VkImageViewSampleWeightCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImageViewSampleWeightCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewSampleWeightCreateInfoQCOM* ptr() { return reinterpret_cast<VkImageViewSampleWeightCreateInfoQCOM*>(this); }
+    VkImageViewSampleWeightCreateInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkImageViewSampleWeightCreateInfoQCOM const*>(this);
+    }
+};
+struct PhysicalDeviceImageProcessingFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 textureSampleWeighted;
+    VkBool32 textureBoxFilter;
+    VkBool32 textureBlockMatch;
+
+    PhysicalDeviceImageProcessingFeaturesQCOM(const VkPhysicalDeviceImageProcessingFeaturesQCOM* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceImageProcessingFeaturesQCOM(const PhysicalDeviceImageProcessingFeaturesQCOM& copy_src);
+    PhysicalDeviceImageProcessingFeaturesQCOM& operator=(const PhysicalDeviceImageProcessingFeaturesQCOM& copy_src);
+    PhysicalDeviceImageProcessingFeaturesQCOM();
+    ~PhysicalDeviceImageProcessingFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceImageProcessingFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageProcessingFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceImageProcessingFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM const*>(this);
+    }
+};
+struct PhysicalDeviceImageProcessingPropertiesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxWeightFilterPhases;
+    VkExtent2D maxWeightFilterDimension;
+    VkExtent2D maxBlockMatchRegion;
+    VkExtent2D maxBoxFilterBlockSize;
+
+    PhysicalDeviceImageProcessingPropertiesQCOM(const VkPhysicalDeviceImageProcessingPropertiesQCOM* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceImageProcessingPropertiesQCOM(const PhysicalDeviceImageProcessingPropertiesQCOM& copy_src);
+    PhysicalDeviceImageProcessingPropertiesQCOM& operator=(const PhysicalDeviceImageProcessingPropertiesQCOM& copy_src);
+    PhysicalDeviceImageProcessingPropertiesQCOM();
+    ~PhysicalDeviceImageProcessingPropertiesQCOM();
+    void initialize(const VkPhysicalDeviceImageProcessingPropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageProcessingPropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessingPropertiesQCOM*>(this);
+    }
+    VkPhysicalDeviceImageProcessingPropertiesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessingPropertiesQCOM const*>(this);
+    }
+};
+struct PhysicalDeviceNestedCommandBufferFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 nestedCommandBuffer;
+    VkBool32 nestedCommandBufferRendering;
+    VkBool32 nestedCommandBufferSimultaneousUse;
+
+    PhysicalDeviceNestedCommandBufferFeaturesEXT(const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceNestedCommandBufferFeaturesEXT(const PhysicalDeviceNestedCommandBufferFeaturesEXT& copy_src);
+    PhysicalDeviceNestedCommandBufferFeaturesEXT& operator=(const PhysicalDeviceNestedCommandBufferFeaturesEXT& copy_src);
+    PhysicalDeviceNestedCommandBufferFeaturesEXT();
+    ~PhysicalDeviceNestedCommandBufferFeaturesEXT();
+    void initialize(const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceNestedCommandBufferFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceNestedCommandBufferFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceNestedCommandBufferFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceNestedCommandBufferFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceNestedCommandBufferPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxCommandBufferNestingLevel;
+
+    PhysicalDeviceNestedCommandBufferPropertiesEXT(const VkPhysicalDeviceNestedCommandBufferPropertiesEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceNestedCommandBufferPropertiesEXT(const PhysicalDeviceNestedCommandBufferPropertiesEXT& copy_src);
+    PhysicalDeviceNestedCommandBufferPropertiesEXT& operator=(const PhysicalDeviceNestedCommandBufferPropertiesEXT& copy_src);
+    PhysicalDeviceNestedCommandBufferPropertiesEXT();
+    ~PhysicalDeviceNestedCommandBufferPropertiesEXT();
+    void initialize(const VkPhysicalDeviceNestedCommandBufferPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceNestedCommandBufferPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceNestedCommandBufferPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceNestedCommandBufferPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceNestedCommandBufferPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceNestedCommandBufferPropertiesEXT const*>(this);
+    }
+};
+struct ExternalMemoryAcquireUnmodifiedEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 acquireUnmodifiedMemory;
+
+    ExternalMemoryAcquireUnmodifiedEXT(const VkExternalMemoryAcquireUnmodifiedEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    ExternalMemoryAcquireUnmodifiedEXT(const ExternalMemoryAcquireUnmodifiedEXT& copy_src);
+    ExternalMemoryAcquireUnmodifiedEXT& operator=(const ExternalMemoryAcquireUnmodifiedEXT& copy_src);
+    ExternalMemoryAcquireUnmodifiedEXT();
+    ~ExternalMemoryAcquireUnmodifiedEXT();
+    void initialize(const VkExternalMemoryAcquireUnmodifiedEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExternalMemoryAcquireUnmodifiedEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExternalMemoryAcquireUnmodifiedEXT* ptr() { return reinterpret_cast<VkExternalMemoryAcquireUnmodifiedEXT*>(this); }
+    VkExternalMemoryAcquireUnmodifiedEXT const* ptr() const {
+        return reinterpret_cast<VkExternalMemoryAcquireUnmodifiedEXT const*>(this);
+    }
+};
+struct PhysicalDeviceExtendedDynamicState3FeaturesEXT {
+    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;
+
+    PhysicalDeviceExtendedDynamicState3FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExtendedDynamicState3FeaturesEXT(const PhysicalDeviceExtendedDynamicState3FeaturesEXT& copy_src);
+    PhysicalDeviceExtendedDynamicState3FeaturesEXT& operator=(const PhysicalDeviceExtendedDynamicState3FeaturesEXT& copy_src);
+    PhysicalDeviceExtendedDynamicState3FeaturesEXT();
+    ~PhysicalDeviceExtendedDynamicState3FeaturesEXT();
+    void initialize(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExtendedDynamicState3FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceExtendedDynamicState3PropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 dynamicPrimitiveTopologyUnrestricted;
+
+    PhysicalDeviceExtendedDynamicState3PropertiesEXT(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExtendedDynamicState3PropertiesEXT(const PhysicalDeviceExtendedDynamicState3PropertiesEXT& copy_src);
+    PhysicalDeviceExtendedDynamicState3PropertiesEXT& operator=(const PhysicalDeviceExtendedDynamicState3PropertiesEXT& copy_src);
+    PhysicalDeviceExtendedDynamicState3PropertiesEXT();
+    ~PhysicalDeviceExtendedDynamicState3PropertiesEXT();
+    void initialize(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExtendedDynamicState3PropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 subpassMergeFeedback;
+
+    PhysicalDeviceSubpassMergeFeedbackFeaturesEXT(const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceSubpassMergeFeedbackFeaturesEXT(const PhysicalDeviceSubpassMergeFeedbackFeaturesEXT& copy_src);
+    PhysicalDeviceSubpassMergeFeedbackFeaturesEXT& operator=(const PhysicalDeviceSubpassMergeFeedbackFeaturesEXT& copy_src);
+    PhysicalDeviceSubpassMergeFeedbackFeaturesEXT();
+    ~PhysicalDeviceSubpassMergeFeedbackFeaturesEXT();
+    void initialize(const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceSubpassMergeFeedbackFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const*>(this);
+    }
+};
+struct RenderPassCreationControlEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 disallowMerging;
+
+    RenderPassCreationControlEXT(const VkRenderPassCreationControlEXT* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    RenderPassCreationControlEXT(const RenderPassCreationControlEXT& copy_src);
+    RenderPassCreationControlEXT& operator=(const RenderPassCreationControlEXT& copy_src);
+    RenderPassCreationControlEXT();
+    ~RenderPassCreationControlEXT();
+    void initialize(const VkRenderPassCreationControlEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassCreationControlEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassCreationControlEXT* ptr() { return reinterpret_cast<VkRenderPassCreationControlEXT*>(this); }
+    VkRenderPassCreationControlEXT const* ptr() const { return reinterpret_cast<VkRenderPassCreationControlEXT const*>(this); }
+};
+struct RenderPassCreationFeedbackCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback{};
+
+    RenderPassCreationFeedbackCreateInfoEXT(const VkRenderPassCreationFeedbackCreateInfoEXT* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderPassCreationFeedbackCreateInfoEXT(const RenderPassCreationFeedbackCreateInfoEXT& copy_src);
+    RenderPassCreationFeedbackCreateInfoEXT& operator=(const RenderPassCreationFeedbackCreateInfoEXT& copy_src);
+    RenderPassCreationFeedbackCreateInfoEXT();
+    ~RenderPassCreationFeedbackCreateInfoEXT();
+    void initialize(const VkRenderPassCreationFeedbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassCreationFeedbackCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassCreationFeedbackCreateInfoEXT* ptr() { return reinterpret_cast<VkRenderPassCreationFeedbackCreateInfoEXT*>(this); }
+    VkRenderPassCreationFeedbackCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderPassCreationFeedbackCreateInfoEXT const*>(this);
+    }
+};
+struct RenderPassSubpassFeedbackCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback{};
+
+    RenderPassSubpassFeedbackCreateInfoEXT(const VkRenderPassSubpassFeedbackCreateInfoEXT* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RenderPassSubpassFeedbackCreateInfoEXT(const RenderPassSubpassFeedbackCreateInfoEXT& copy_src);
+    RenderPassSubpassFeedbackCreateInfoEXT& operator=(const RenderPassSubpassFeedbackCreateInfoEXT& copy_src);
+    RenderPassSubpassFeedbackCreateInfoEXT();
+    ~RenderPassSubpassFeedbackCreateInfoEXT();
+    void initialize(const VkRenderPassSubpassFeedbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RenderPassSubpassFeedbackCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassSubpassFeedbackCreateInfoEXT* ptr() { return reinterpret_cast<VkRenderPassSubpassFeedbackCreateInfoEXT*>(this); }
+    VkRenderPassSubpassFeedbackCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderPassSubpassFeedbackCreateInfoEXT const*>(this);
+    }
+};
+struct DirectDriverLoadingInfoLUNARG {
+    VkStructureType sType;
+    void* pNext{};
+    VkDirectDriverLoadingFlagsLUNARG flags;
+    PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr;
+
+    DirectDriverLoadingInfoLUNARG(const VkDirectDriverLoadingInfoLUNARG* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    DirectDriverLoadingInfoLUNARG(const DirectDriverLoadingInfoLUNARG& copy_src);
+    DirectDriverLoadingInfoLUNARG& operator=(const DirectDriverLoadingInfoLUNARG& copy_src);
+    DirectDriverLoadingInfoLUNARG();
+    ~DirectDriverLoadingInfoLUNARG();
+    void initialize(const VkDirectDriverLoadingInfoLUNARG* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DirectDriverLoadingInfoLUNARG* copy_src, PNextCopyState* copy_state = {});
+    VkDirectDriverLoadingInfoLUNARG* ptr() { return reinterpret_cast<VkDirectDriverLoadingInfoLUNARG*>(this); }
+    VkDirectDriverLoadingInfoLUNARG const* ptr() const { return reinterpret_cast<VkDirectDriverLoadingInfoLUNARG const*>(this); }
+};
+struct DirectDriverLoadingListLUNARG {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDirectDriverLoadingModeLUNARG mode;
+    uint32_t driverCount;
+    DirectDriverLoadingInfoLUNARG* pDrivers{};
+
+    DirectDriverLoadingListLUNARG(const VkDirectDriverLoadingListLUNARG* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    DirectDriverLoadingListLUNARG(const DirectDriverLoadingListLUNARG& copy_src);
+    DirectDriverLoadingListLUNARG& operator=(const DirectDriverLoadingListLUNARG& copy_src);
+    DirectDriverLoadingListLUNARG();
+    ~DirectDriverLoadingListLUNARG();
+    void initialize(const VkDirectDriverLoadingListLUNARG* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const DirectDriverLoadingListLUNARG* copy_src, PNextCopyState* copy_state = {});
+    VkDirectDriverLoadingListLUNARG* ptr() { return reinterpret_cast<VkDirectDriverLoadingListLUNARG*>(this); }
+    VkDirectDriverLoadingListLUNARG const* ptr() const { return reinterpret_cast<VkDirectDriverLoadingListLUNARG const*>(this); }
+};
+struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderModuleIdentifier;
+
+    PhysicalDeviceShaderModuleIdentifierFeaturesEXT(const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderModuleIdentifierFeaturesEXT(const PhysicalDeviceShaderModuleIdentifierFeaturesEXT& copy_src);
+    PhysicalDeviceShaderModuleIdentifierFeaturesEXT& operator=(const PhysicalDeviceShaderModuleIdentifierFeaturesEXT& copy_src);
+    PhysicalDeviceShaderModuleIdentifierFeaturesEXT();
+    ~PhysicalDeviceShaderModuleIdentifierFeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderModuleIdentifierFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE];
+
+    PhysicalDeviceShaderModuleIdentifierPropertiesEXT(const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderModuleIdentifierPropertiesEXT(const PhysicalDeviceShaderModuleIdentifierPropertiesEXT& copy_src);
+    PhysicalDeviceShaderModuleIdentifierPropertiesEXT& operator=(const PhysicalDeviceShaderModuleIdentifierPropertiesEXT& copy_src);
+    PhysicalDeviceShaderModuleIdentifierPropertiesEXT();
+    ~PhysicalDeviceShaderModuleIdentifierPropertiesEXT();
+    void initialize(const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderModuleIdentifierPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const*>(this);
+    }
+};
+struct PipelineShaderStageModuleIdentifierCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t identifierSize;
+    const uint8_t* pIdentifier{};
+
+    PipelineShaderStageModuleIdentifierCreateInfoEXT(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PipelineShaderStageModuleIdentifierCreateInfoEXT(const PipelineShaderStageModuleIdentifierCreateInfoEXT& copy_src);
+    PipelineShaderStageModuleIdentifierCreateInfoEXT& operator=(const PipelineShaderStageModuleIdentifierCreateInfoEXT& copy_src);
+    PipelineShaderStageModuleIdentifierCreateInfoEXT();
+    ~PipelineShaderStageModuleIdentifierCreateInfoEXT();
+    void initialize(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PipelineShaderStageModuleIdentifierCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(this);
+    }
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT const*>(this);
+    }
+};
+struct ShaderModuleIdentifierEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t identifierSize;
+    uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT];
+
+    ShaderModuleIdentifierEXT(const VkShaderModuleIdentifierEXT* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    ShaderModuleIdentifierEXT(const ShaderModuleIdentifierEXT& copy_src);
+    ShaderModuleIdentifierEXT& operator=(const ShaderModuleIdentifierEXT& copy_src);
+    ShaderModuleIdentifierEXT();
+    ~ShaderModuleIdentifierEXT();
+    void initialize(const VkShaderModuleIdentifierEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ShaderModuleIdentifierEXT* copy_src, PNextCopyState* copy_state = {});
+    VkShaderModuleIdentifierEXT* ptr() { return reinterpret_cast<VkShaderModuleIdentifierEXT*>(this); }
+    VkShaderModuleIdentifierEXT const* ptr() const { return reinterpret_cast<VkShaderModuleIdentifierEXT const*>(this); }
+};
+struct PhysicalDeviceOpticalFlowFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 opticalFlow;
+
+    PhysicalDeviceOpticalFlowFeaturesNV(const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    PhysicalDeviceOpticalFlowFeaturesNV(const PhysicalDeviceOpticalFlowFeaturesNV& copy_src);
+    PhysicalDeviceOpticalFlowFeaturesNV& operator=(const PhysicalDeviceOpticalFlowFeaturesNV& copy_src);
+    PhysicalDeviceOpticalFlowFeaturesNV();
+    ~PhysicalDeviceOpticalFlowFeaturesNV();
+    void initialize(const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceOpticalFlowFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceOpticalFlowFeaturesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceOpticalFlowFeaturesNV*>(this); }
+    VkPhysicalDeviceOpticalFlowFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceOpticalFlowFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceOpticalFlowPropertiesNV {
+    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;
+
+    PhysicalDeviceOpticalFlowPropertiesNV(const VkPhysicalDeviceOpticalFlowPropertiesNV* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDeviceOpticalFlowPropertiesNV(const PhysicalDeviceOpticalFlowPropertiesNV& copy_src);
+    PhysicalDeviceOpticalFlowPropertiesNV& operator=(const PhysicalDeviceOpticalFlowPropertiesNV& copy_src);
+    PhysicalDeviceOpticalFlowPropertiesNV();
+    ~PhysicalDeviceOpticalFlowPropertiesNV();
+    void initialize(const VkPhysicalDeviceOpticalFlowPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceOpticalFlowPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceOpticalFlowPropertiesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceOpticalFlowPropertiesNV*>(this); }
+    VkPhysicalDeviceOpticalFlowPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceOpticalFlowPropertiesNV const*>(this);
+    }
+};
+struct OpticalFlowImageFormatInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkOpticalFlowUsageFlagsNV usage;
+
+    OpticalFlowImageFormatInfoNV(const VkOpticalFlowImageFormatInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    OpticalFlowImageFormatInfoNV(const OpticalFlowImageFormatInfoNV& copy_src);
+    OpticalFlowImageFormatInfoNV& operator=(const OpticalFlowImageFormatInfoNV& copy_src);
+    OpticalFlowImageFormatInfoNV();
+    ~OpticalFlowImageFormatInfoNV();
+    void initialize(const VkOpticalFlowImageFormatInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const OpticalFlowImageFormatInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkOpticalFlowImageFormatInfoNV* ptr() { return reinterpret_cast<VkOpticalFlowImageFormatInfoNV*>(this); }
+    VkOpticalFlowImageFormatInfoNV const* ptr() const { return reinterpret_cast<VkOpticalFlowImageFormatInfoNV const*>(this); }
+};
+struct OpticalFlowImageFormatPropertiesNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat format;
+
+    OpticalFlowImageFormatPropertiesNV(const VkOpticalFlowImageFormatPropertiesNV* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    OpticalFlowImageFormatPropertiesNV(const OpticalFlowImageFormatPropertiesNV& copy_src);
+    OpticalFlowImageFormatPropertiesNV& operator=(const OpticalFlowImageFormatPropertiesNV& copy_src);
+    OpticalFlowImageFormatPropertiesNV();
+    ~OpticalFlowImageFormatPropertiesNV();
+    void initialize(const VkOpticalFlowImageFormatPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const OpticalFlowImageFormatPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkOpticalFlowImageFormatPropertiesNV* ptr() { return reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV*>(this); }
+    VkOpticalFlowImageFormatPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV const*>(this);
+    }
+};
+struct OpticalFlowSessionCreateInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t width;
+    uint32_t height;
+    VkFormat imageFormat;
+    VkFormat flowVectorFormat;
+    VkFormat costFormat;
+    VkOpticalFlowGridSizeFlagsNV outputGridSize;
+    VkOpticalFlowGridSizeFlagsNV hintGridSize;
+    VkOpticalFlowPerformanceLevelNV performanceLevel;
+    VkOpticalFlowSessionCreateFlagsNV flags;
+
+    OpticalFlowSessionCreateInfoNV(const VkOpticalFlowSessionCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    OpticalFlowSessionCreateInfoNV(const OpticalFlowSessionCreateInfoNV& copy_src);
+    OpticalFlowSessionCreateInfoNV& operator=(const OpticalFlowSessionCreateInfoNV& copy_src);
+    OpticalFlowSessionCreateInfoNV();
+    ~OpticalFlowSessionCreateInfoNV();
+    void initialize(const VkOpticalFlowSessionCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const OpticalFlowSessionCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkOpticalFlowSessionCreateInfoNV* ptr() { return reinterpret_cast<VkOpticalFlowSessionCreateInfoNV*>(this); }
+    VkOpticalFlowSessionCreateInfoNV const* ptr() const { return reinterpret_cast<VkOpticalFlowSessionCreateInfoNV const*>(this); }
+};
+struct OpticalFlowSessionCreatePrivateDataInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t id;
+    uint32_t size;
+    const void* pPrivateData{};
+
+    OpticalFlowSessionCreatePrivateDataInfoNV(const VkOpticalFlowSessionCreatePrivateDataInfoNV* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    OpticalFlowSessionCreatePrivateDataInfoNV(const OpticalFlowSessionCreatePrivateDataInfoNV& copy_src);
+    OpticalFlowSessionCreatePrivateDataInfoNV& operator=(const OpticalFlowSessionCreatePrivateDataInfoNV& copy_src);
+    OpticalFlowSessionCreatePrivateDataInfoNV();
+    ~OpticalFlowSessionCreatePrivateDataInfoNV();
+    void initialize(const VkOpticalFlowSessionCreatePrivateDataInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const OpticalFlowSessionCreatePrivateDataInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* ptr() {
+        return reinterpret_cast<VkOpticalFlowSessionCreatePrivateDataInfoNV*>(this);
+    }
+    VkOpticalFlowSessionCreatePrivateDataInfoNV const* ptr() const {
+        return reinterpret_cast<VkOpticalFlowSessionCreatePrivateDataInfoNV const*>(this);
+    }
+};
+struct OpticalFlowExecuteInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkOpticalFlowExecuteFlagsNV flags;
+    uint32_t regionCount;
+    const VkRect2D* pRegions{};
+
+    OpticalFlowExecuteInfoNV(const VkOpticalFlowExecuteInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    OpticalFlowExecuteInfoNV(const OpticalFlowExecuteInfoNV& copy_src);
+    OpticalFlowExecuteInfoNV& operator=(const OpticalFlowExecuteInfoNV& copy_src);
+    OpticalFlowExecuteInfoNV();
+    ~OpticalFlowExecuteInfoNV();
+    void initialize(const VkOpticalFlowExecuteInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const OpticalFlowExecuteInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkOpticalFlowExecuteInfoNV* ptr() { return reinterpret_cast<VkOpticalFlowExecuteInfoNV*>(this); }
+    VkOpticalFlowExecuteInfoNV const* ptr() const { return reinterpret_cast<VkOpticalFlowExecuteInfoNV const*>(this); }
+};
+struct PhysicalDeviceLegacyDitheringFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 legacyDithering;
+
+    PhysicalDeviceLegacyDitheringFeaturesEXT(const VkPhysicalDeviceLegacyDitheringFeaturesEXT* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceLegacyDitheringFeaturesEXT(const PhysicalDeviceLegacyDitheringFeaturesEXT& copy_src);
+    PhysicalDeviceLegacyDitheringFeaturesEXT& operator=(const PhysicalDeviceLegacyDitheringFeaturesEXT& copy_src);
+    PhysicalDeviceLegacyDitheringFeaturesEXT();
+    ~PhysicalDeviceLegacyDitheringFeaturesEXT();
+    void initialize(const VkPhysicalDeviceLegacyDitheringFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceLegacyDitheringFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDevicePipelineProtectedAccessFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineProtectedAccess;
+
+    PhysicalDevicePipelineProtectedAccessFeaturesEXT(const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePipelineProtectedAccessFeaturesEXT(const PhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src);
+    PhysicalDevicePipelineProtectedAccessFeaturesEXT& operator=(const PhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src);
+    PhysicalDevicePipelineProtectedAccessFeaturesEXT();
+    ~PhysicalDevicePipelineProtectedAccessFeaturesEXT();
+    void initialize(const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePipelineProtectedAccessFeaturesEXT* 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 PhysicalDeviceExternalFormatResolveFeaturesANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 externalFormatResolve;
+
+    PhysicalDeviceExternalFormatResolveFeaturesANDROID(const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExternalFormatResolveFeaturesANDROID(const PhysicalDeviceExternalFormatResolveFeaturesANDROID& copy_src);
+    PhysicalDeviceExternalFormatResolveFeaturesANDROID& operator=(
+        const PhysicalDeviceExternalFormatResolveFeaturesANDROID& copy_src);
+    PhysicalDeviceExternalFormatResolveFeaturesANDROID();
+    ~PhysicalDeviceExternalFormatResolveFeaturesANDROID();
+    void initialize(const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExternalFormatResolveFeaturesANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(this);
+    }
+    VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const*>(this);
+    }
+};
+struct PhysicalDeviceExternalFormatResolvePropertiesANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 nullColorAttachmentWithExternalFormatResolve;
+    VkChromaLocation externalFormatResolveChromaOffsetX;
+    VkChromaLocation externalFormatResolveChromaOffsetY;
+
+    PhysicalDeviceExternalFormatResolvePropertiesANDROID(const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExternalFormatResolvePropertiesANDROID(const PhysicalDeviceExternalFormatResolvePropertiesANDROID& copy_src);
+    PhysicalDeviceExternalFormatResolvePropertiesANDROID& operator=(
+        const PhysicalDeviceExternalFormatResolvePropertiesANDROID& copy_src);
+    PhysicalDeviceExternalFormatResolvePropertiesANDROID();
+    ~PhysicalDeviceExternalFormatResolvePropertiesANDROID();
+    void initialize(const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExternalFormatResolvePropertiesANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID*>(this);
+    }
+    VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const*>(this);
+    }
+};
+struct AndroidHardwareBufferFormatResolvePropertiesANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat colorAttachmentFormat;
+
+    AndroidHardwareBufferFormatResolvePropertiesANDROID(const VkAndroidHardwareBufferFormatResolvePropertiesANDROID* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AndroidHardwareBufferFormatResolvePropertiesANDROID(const AndroidHardwareBufferFormatResolvePropertiesANDROID& copy_src);
+    AndroidHardwareBufferFormatResolvePropertiesANDROID& operator=(
+        const AndroidHardwareBufferFormatResolvePropertiesANDROID& copy_src);
+    AndroidHardwareBufferFormatResolvePropertiesANDROID();
+    ~AndroidHardwareBufferFormatResolvePropertiesANDROID();
+    void initialize(const VkAndroidHardwareBufferFormatResolvePropertiesANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AndroidHardwareBufferFormatResolvePropertiesANDROID* 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 PhysicalDeviceShaderObjectFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderObject;
+
+    PhysicalDeviceShaderObjectFeaturesEXT(const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDeviceShaderObjectFeaturesEXT(const PhysicalDeviceShaderObjectFeaturesEXT& copy_src);
+    PhysicalDeviceShaderObjectFeaturesEXT& operator=(const PhysicalDeviceShaderObjectFeaturesEXT& copy_src);
+    PhysicalDeviceShaderObjectFeaturesEXT();
+    ~PhysicalDeviceShaderObjectFeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderObjectFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderObjectFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderObjectFeaturesEXT*>(this); }
+    VkPhysicalDeviceShaderObjectFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderObjectFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceShaderObjectPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint8_t shaderBinaryUUID[VK_UUID_SIZE];
+    uint32_t shaderBinaryVersion;
+
+    PhysicalDeviceShaderObjectPropertiesEXT(const VkPhysicalDeviceShaderObjectPropertiesEXT* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderObjectPropertiesEXT(const PhysicalDeviceShaderObjectPropertiesEXT& copy_src);
+    PhysicalDeviceShaderObjectPropertiesEXT& operator=(const PhysicalDeviceShaderObjectPropertiesEXT& copy_src);
+    PhysicalDeviceShaderObjectPropertiesEXT();
+    ~PhysicalDeviceShaderObjectPropertiesEXT();
+    void initialize(const VkPhysicalDeviceShaderObjectPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderObjectPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderObjectPropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderObjectPropertiesEXT*>(this); }
+    VkPhysicalDeviceShaderObjectPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderObjectPropertiesEXT const*>(this);
+    }
+};
+struct ShaderCreateInfoEXT {
+    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{};
+    SpecializationInfo* pSpecializationInfo{};
+
+    ShaderCreateInfoEXT(const VkShaderCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ShaderCreateInfoEXT(const ShaderCreateInfoEXT& copy_src);
+    ShaderCreateInfoEXT& operator=(const ShaderCreateInfoEXT& copy_src);
+    ShaderCreateInfoEXT();
+    ~ShaderCreateInfoEXT();
+    void initialize(const VkShaderCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ShaderCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkShaderCreateInfoEXT* ptr() { return reinterpret_cast<VkShaderCreateInfoEXT*>(this); }
+    VkShaderCreateInfoEXT const* ptr() const { return reinterpret_cast<VkShaderCreateInfoEXT const*>(this); }
+};
+struct PhysicalDeviceTilePropertiesFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 tileProperties;
+
+    PhysicalDeviceTilePropertiesFeaturesQCOM(const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceTilePropertiesFeaturesQCOM(const PhysicalDeviceTilePropertiesFeaturesQCOM& copy_src);
+    PhysicalDeviceTilePropertiesFeaturesQCOM& operator=(const PhysicalDeviceTilePropertiesFeaturesQCOM& copy_src);
+    PhysicalDeviceTilePropertiesFeaturesQCOM();
+    ~PhysicalDeviceTilePropertiesFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceTilePropertiesFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM const*>(this);
+    }
+};
+struct TilePropertiesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent3D tileSize;
+    VkExtent2D apronSize;
+    VkOffset2D origin;
+
+    TilePropertiesQCOM(const VkTilePropertiesQCOM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    TilePropertiesQCOM(const TilePropertiesQCOM& copy_src);
+    TilePropertiesQCOM& operator=(const TilePropertiesQCOM& copy_src);
+    TilePropertiesQCOM();
+    ~TilePropertiesQCOM();
+    void initialize(const VkTilePropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const TilePropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkTilePropertiesQCOM* ptr() { return reinterpret_cast<VkTilePropertiesQCOM*>(this); }
+    VkTilePropertiesQCOM const* ptr() const { return reinterpret_cast<VkTilePropertiesQCOM const*>(this); }
+};
+struct PhysicalDeviceAmigoProfilingFeaturesSEC {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 amigoProfiling;
+
+    PhysicalDeviceAmigoProfilingFeaturesSEC(const VkPhysicalDeviceAmigoProfilingFeaturesSEC* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceAmigoProfilingFeaturesSEC(const PhysicalDeviceAmigoProfilingFeaturesSEC& copy_src);
+    PhysicalDeviceAmigoProfilingFeaturesSEC& operator=(const PhysicalDeviceAmigoProfilingFeaturesSEC& copy_src);
+    PhysicalDeviceAmigoProfilingFeaturesSEC();
+    ~PhysicalDeviceAmigoProfilingFeaturesSEC();
+    void initialize(const VkPhysicalDeviceAmigoProfilingFeaturesSEC* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceAmigoProfilingFeaturesSEC* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAmigoProfilingFeaturesSEC* ptr() { return reinterpret_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(this); }
+    VkPhysicalDeviceAmigoProfilingFeaturesSEC const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC const*>(this);
+    }
+};
+struct AmigoProfilingSubmitInfoSEC {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t firstDrawTimestamp;
+    uint64_t swapBufferTimestamp;
+
+    AmigoProfilingSubmitInfoSEC(const VkAmigoProfilingSubmitInfoSEC* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    AmigoProfilingSubmitInfoSEC(const AmigoProfilingSubmitInfoSEC& copy_src);
+    AmigoProfilingSubmitInfoSEC& operator=(const AmigoProfilingSubmitInfoSEC& copy_src);
+    AmigoProfilingSubmitInfoSEC();
+    ~AmigoProfilingSubmitInfoSEC();
+    void initialize(const VkAmigoProfilingSubmitInfoSEC* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AmigoProfilingSubmitInfoSEC* copy_src, PNextCopyState* copy_state = {});
+    VkAmigoProfilingSubmitInfoSEC* ptr() { return reinterpret_cast<VkAmigoProfilingSubmitInfoSEC*>(this); }
+    VkAmigoProfilingSubmitInfoSEC const* ptr() const { return reinterpret_cast<VkAmigoProfilingSubmitInfoSEC const*>(this); }
+};
+struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 multiviewPerViewViewports;
+
+    PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(const PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& copy_src);
+    PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& operator=(
+        const PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& copy_src);
+    PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM();
+    ~PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const*>(this);
+    }
+};
+struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint;
+
+    PhysicalDeviceRayTracingInvocationReorderPropertiesNV(const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRayTracingInvocationReorderPropertiesNV(const PhysicalDeviceRayTracingInvocationReorderPropertiesNV& copy_src);
+    PhysicalDeviceRayTracingInvocationReorderPropertiesNV& operator=(
+        const PhysicalDeviceRayTracingInvocationReorderPropertiesNV& copy_src);
+    PhysicalDeviceRayTracingInvocationReorderPropertiesNV();
+    ~PhysicalDeviceRayTracingInvocationReorderPropertiesNV();
+    void initialize(const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRayTracingInvocationReorderPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const*>(this);
+    }
+};
+struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingInvocationReorder;
+
+    PhysicalDeviceRayTracingInvocationReorderFeaturesNV(const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRayTracingInvocationReorderFeaturesNV(const PhysicalDeviceRayTracingInvocationReorderFeaturesNV& copy_src);
+    PhysicalDeviceRayTracingInvocationReorderFeaturesNV& operator=(
+        const PhysicalDeviceRayTracingInvocationReorderFeaturesNV& copy_src);
+    PhysicalDeviceRayTracingInvocationReorderFeaturesNV();
+    ~PhysicalDeviceRayTracingInvocationReorderFeaturesNV();
+    void initialize(const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRayTracingInvocationReorderFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 extendedSparseAddressSpace;
+
+    PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(const PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& copy_src);
+    PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& operator=(
+        const PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& copy_src);
+    PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV();
+    ~PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV();
+    void initialize(const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize extendedSparseAddressSpaceSize;
+    VkImageUsageFlags extendedSparseImageUsageFlags;
+    VkBufferUsageFlags extendedSparseBufferUsageFlags;
+
+    PhysicalDeviceExtendedSparseAddressSpacePropertiesNV(const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExtendedSparseAddressSpacePropertiesNV(const PhysicalDeviceExtendedSparseAddressSpacePropertiesNV& copy_src);
+    PhysicalDeviceExtendedSparseAddressSpacePropertiesNV& operator=(
+        const PhysicalDeviceExtendedSparseAddressSpacePropertiesNV& copy_src);
+    PhysicalDeviceExtendedSparseAddressSpacePropertiesNV();
+    ~PhysicalDeviceExtendedSparseAddressSpacePropertiesNV();
+    void initialize(const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExtendedSparseAddressSpacePropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV*>(this);
+    }
+    VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const*>(this);
+    }
+};
+struct LayerSettingEXT {
+    const char* pLayerName{};
+    const char* pSettingName{};
+    VkLayerSettingTypeEXT type;
+    uint32_t valueCount;
+    const void* pValues{};
+
+    LayerSettingEXT(const VkLayerSettingEXT* in_struct, PNextCopyState* copy_state = {});
+    LayerSettingEXT(const LayerSettingEXT& copy_src);
+    LayerSettingEXT& operator=(const LayerSettingEXT& copy_src);
+    LayerSettingEXT();
+    ~LayerSettingEXT();
+    void initialize(const VkLayerSettingEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const LayerSettingEXT* copy_src, PNextCopyState* copy_state = {});
+    VkLayerSettingEXT* ptr() { return reinterpret_cast<VkLayerSettingEXT*>(this); }
+    VkLayerSettingEXT const* ptr() const { return reinterpret_cast<VkLayerSettingEXT const*>(this); }
+};
+struct LayerSettingsCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t settingCount;
+    LayerSettingEXT* pSettings{};
+
+    LayerSettingsCreateInfoEXT(const VkLayerSettingsCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                               bool copy_pnext = true);
+    LayerSettingsCreateInfoEXT(const LayerSettingsCreateInfoEXT& copy_src);
+    LayerSettingsCreateInfoEXT& operator=(const LayerSettingsCreateInfoEXT& copy_src);
+    LayerSettingsCreateInfoEXT();
+    ~LayerSettingsCreateInfoEXT();
+    void initialize(const VkLayerSettingsCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const LayerSettingsCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkLayerSettingsCreateInfoEXT* ptr() { return reinterpret_cast<VkLayerSettingsCreateInfoEXT*>(this); }
+    VkLayerSettingsCreateInfoEXT const* ptr() const { return reinterpret_cast<VkLayerSettingsCreateInfoEXT const*>(this); }
+};
+struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderCoreBuiltins;
+
+    PhysicalDeviceShaderCoreBuiltinsFeaturesARM(const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderCoreBuiltinsFeaturesARM(const PhysicalDeviceShaderCoreBuiltinsFeaturesARM& copy_src);
+    PhysicalDeviceShaderCoreBuiltinsFeaturesARM& operator=(const PhysicalDeviceShaderCoreBuiltinsFeaturesARM& copy_src);
+    PhysicalDeviceShaderCoreBuiltinsFeaturesARM();
+    ~PhysicalDeviceShaderCoreBuiltinsFeaturesARM();
+    void initialize(const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderCoreBuiltinsFeaturesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(this);
+    }
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const*>(this);
+    }
+};
+struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t shaderCoreMask;
+    uint32_t shaderCoreCount;
+    uint32_t shaderWarpsPerCore;
+
+    PhysicalDeviceShaderCoreBuiltinsPropertiesARM(const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderCoreBuiltinsPropertiesARM(const PhysicalDeviceShaderCoreBuiltinsPropertiesARM& copy_src);
+    PhysicalDeviceShaderCoreBuiltinsPropertiesARM& operator=(const PhysicalDeviceShaderCoreBuiltinsPropertiesARM& copy_src);
+    PhysicalDeviceShaderCoreBuiltinsPropertiesARM();
+    ~PhysicalDeviceShaderCoreBuiltinsPropertiesARM();
+    void initialize(const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderCoreBuiltinsPropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(this);
+    }
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const*>(this);
+    }
+};
+struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineLibraryGroupHandles;
+
+    PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(const PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& copy_src);
+    PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& operator=(
+        const PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& copy_src);
+    PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT();
+    ~PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT();
+    void initialize(const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 dynamicRenderingUnusedAttachments;
+
+    PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+        const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+        const PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& copy_src);
+    PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& operator=(
+        const PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& copy_src);
+    PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT();
+    ~PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const*>(this);
+    }
+};
+struct LatencySleepModeInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 lowLatencyMode;
+    VkBool32 lowLatencyBoost;
+    uint32_t minimumIntervalUs;
+
+    LatencySleepModeInfoNV(const VkLatencySleepModeInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    LatencySleepModeInfoNV(const LatencySleepModeInfoNV& copy_src);
+    LatencySleepModeInfoNV& operator=(const LatencySleepModeInfoNV& copy_src);
+    LatencySleepModeInfoNV();
+    ~LatencySleepModeInfoNV();
+    void initialize(const VkLatencySleepModeInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const LatencySleepModeInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkLatencySleepModeInfoNV* ptr() { return reinterpret_cast<VkLatencySleepModeInfoNV*>(this); }
+    VkLatencySleepModeInfoNV const* ptr() const { return reinterpret_cast<VkLatencySleepModeInfoNV const*>(this); }
+};
+struct LatencySleepInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore signalSemaphore;
+    uint64_t value;
+
+    LatencySleepInfoNV(const VkLatencySleepInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    LatencySleepInfoNV(const LatencySleepInfoNV& copy_src);
+    LatencySleepInfoNV& operator=(const LatencySleepInfoNV& copy_src);
+    LatencySleepInfoNV();
+    ~LatencySleepInfoNV();
+    void initialize(const VkLatencySleepInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const LatencySleepInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkLatencySleepInfoNV* ptr() { return reinterpret_cast<VkLatencySleepInfoNV*>(this); }
+    VkLatencySleepInfoNV const* ptr() const { return reinterpret_cast<VkLatencySleepInfoNV const*>(this); }
+};
+struct SetLatencyMarkerInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t presentID;
+    VkLatencyMarkerNV marker;
+
+    SetLatencyMarkerInfoNV(const VkSetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SetLatencyMarkerInfoNV(const SetLatencyMarkerInfoNV& copy_src);
+    SetLatencyMarkerInfoNV& operator=(const SetLatencyMarkerInfoNV& copy_src);
+    SetLatencyMarkerInfoNV();
+    ~SetLatencyMarkerInfoNV();
+    void initialize(const VkSetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SetLatencyMarkerInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkSetLatencyMarkerInfoNV* ptr() { return reinterpret_cast<VkSetLatencyMarkerInfoNV*>(this); }
+    VkSetLatencyMarkerInfoNV const* ptr() const { return reinterpret_cast<VkSetLatencyMarkerInfoNV const*>(this); }
+};
+struct LatencyTimingsFrameReportNV {
+    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;
+
+    LatencyTimingsFrameReportNV(const VkLatencyTimingsFrameReportNV* in_struct, PNextCopyState* copy_state = {},
+                                bool copy_pnext = true);
+    LatencyTimingsFrameReportNV(const LatencyTimingsFrameReportNV& copy_src);
+    LatencyTimingsFrameReportNV& operator=(const LatencyTimingsFrameReportNV& copy_src);
+    LatencyTimingsFrameReportNV();
+    ~LatencyTimingsFrameReportNV();
+    void initialize(const VkLatencyTimingsFrameReportNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const LatencyTimingsFrameReportNV* copy_src, PNextCopyState* copy_state = {});
+    VkLatencyTimingsFrameReportNV* ptr() { return reinterpret_cast<VkLatencyTimingsFrameReportNV*>(this); }
+    VkLatencyTimingsFrameReportNV const* ptr() const { return reinterpret_cast<VkLatencyTimingsFrameReportNV const*>(this); }
+};
+struct GetLatencyMarkerInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t timingCount;
+    LatencyTimingsFrameReportNV* pTimings{};
+
+    GetLatencyMarkerInfoNV(const VkGetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    GetLatencyMarkerInfoNV(const GetLatencyMarkerInfoNV& copy_src);
+    GetLatencyMarkerInfoNV& operator=(const GetLatencyMarkerInfoNV& copy_src);
+    GetLatencyMarkerInfoNV();
+    ~GetLatencyMarkerInfoNV();
+    void initialize(const VkGetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const GetLatencyMarkerInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkGetLatencyMarkerInfoNV* ptr() { return reinterpret_cast<VkGetLatencyMarkerInfoNV*>(this); }
+    VkGetLatencyMarkerInfoNV const* ptr() const { return reinterpret_cast<VkGetLatencyMarkerInfoNV const*>(this); }
+};
+struct LatencySubmissionPresentIdNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t presentID;
+
+    LatencySubmissionPresentIdNV(const VkLatencySubmissionPresentIdNV* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    LatencySubmissionPresentIdNV(const LatencySubmissionPresentIdNV& copy_src);
+    LatencySubmissionPresentIdNV& operator=(const LatencySubmissionPresentIdNV& copy_src);
+    LatencySubmissionPresentIdNV();
+    ~LatencySubmissionPresentIdNV();
+    void initialize(const VkLatencySubmissionPresentIdNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const LatencySubmissionPresentIdNV* copy_src, PNextCopyState* copy_state = {});
+    VkLatencySubmissionPresentIdNV* ptr() { return reinterpret_cast<VkLatencySubmissionPresentIdNV*>(this); }
+    VkLatencySubmissionPresentIdNV const* ptr() const { return reinterpret_cast<VkLatencySubmissionPresentIdNV const*>(this); }
+};
+struct SwapchainLatencyCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 latencyModeEnable;
+
+    SwapchainLatencyCreateInfoNV(const VkSwapchainLatencyCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    SwapchainLatencyCreateInfoNV(const SwapchainLatencyCreateInfoNV& copy_src);
+    SwapchainLatencyCreateInfoNV& operator=(const SwapchainLatencyCreateInfoNV& copy_src);
+    SwapchainLatencyCreateInfoNV();
+    ~SwapchainLatencyCreateInfoNV();
+    void initialize(const VkSwapchainLatencyCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SwapchainLatencyCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainLatencyCreateInfoNV* ptr() { return reinterpret_cast<VkSwapchainLatencyCreateInfoNV*>(this); }
+    VkSwapchainLatencyCreateInfoNV const* ptr() const { return reinterpret_cast<VkSwapchainLatencyCreateInfoNV const*>(this); }
+};
+struct OutOfBandQueueTypeInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkOutOfBandQueueTypeNV queueType;
+
+    OutOfBandQueueTypeInfoNV(const VkOutOfBandQueueTypeInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    OutOfBandQueueTypeInfoNV(const OutOfBandQueueTypeInfoNV& copy_src);
+    OutOfBandQueueTypeInfoNV& operator=(const OutOfBandQueueTypeInfoNV& copy_src);
+    OutOfBandQueueTypeInfoNV();
+    ~OutOfBandQueueTypeInfoNV();
+    void initialize(const VkOutOfBandQueueTypeInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const OutOfBandQueueTypeInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkOutOfBandQueueTypeInfoNV* ptr() { return reinterpret_cast<VkOutOfBandQueueTypeInfoNV*>(this); }
+    VkOutOfBandQueueTypeInfoNV const* ptr() const { return reinterpret_cast<VkOutOfBandQueueTypeInfoNV const*>(this); }
+};
+struct LatencySurfaceCapabilitiesNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t presentModeCount;
+    VkPresentModeKHR* pPresentModes{};
+
+    LatencySurfaceCapabilitiesNV(const VkLatencySurfaceCapabilitiesNV* in_struct, PNextCopyState* copy_state = {},
+                                 bool copy_pnext = true);
+    LatencySurfaceCapabilitiesNV(const LatencySurfaceCapabilitiesNV& copy_src);
+    LatencySurfaceCapabilitiesNV& operator=(const LatencySurfaceCapabilitiesNV& copy_src);
+    LatencySurfaceCapabilitiesNV();
+    ~LatencySurfaceCapabilitiesNV();
+    void initialize(const VkLatencySurfaceCapabilitiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const LatencySurfaceCapabilitiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkLatencySurfaceCapabilitiesNV* ptr() { return reinterpret_cast<VkLatencySurfaceCapabilitiesNV*>(this); }
+    VkLatencySurfaceCapabilitiesNV const* ptr() const { return reinterpret_cast<VkLatencySurfaceCapabilitiesNV const*>(this); }
+};
+struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 multiviewPerViewRenderAreas;
+
+    PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(const PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& copy_src);
+    PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& operator=(
+        const PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& copy_src);
+    PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM();
+    ~PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const*>(this);
+    }
+};
+struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t perViewRenderAreaCount;
+    const VkRect2D* pPerViewRenderAreas{};
+
+    MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(const MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& copy_src);
+    MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& operator=(
+        const MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& copy_src);
+    MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM();
+    ~MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM();
+    void initialize(const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* ptr() {
+        return reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(this);
+    }
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const*>(this);
+    }
+};
+struct PhysicalDevicePerStageDescriptorSetFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 perStageDescriptorSet;
+    VkBool32 dynamicPipelineLayout;
+
+    PhysicalDevicePerStageDescriptorSetFeaturesNV(const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDevicePerStageDescriptorSetFeaturesNV(const PhysicalDevicePerStageDescriptorSetFeaturesNV& copy_src);
+    PhysicalDevicePerStageDescriptorSetFeaturesNV& operator=(const PhysicalDevicePerStageDescriptorSetFeaturesNV& copy_src);
+    PhysicalDevicePerStageDescriptorSetFeaturesNV();
+    ~PhysicalDevicePerStageDescriptorSetFeaturesNV();
+    void initialize(const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDevicePerStageDescriptorSetFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePerStageDescriptorSetFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(this);
+    }
+    VkPhysicalDevicePerStageDescriptorSetFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePerStageDescriptorSetFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceImageProcessing2FeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 textureBlockMatch2;
+
+    PhysicalDeviceImageProcessing2FeaturesQCOM(const VkPhysicalDeviceImageProcessing2FeaturesQCOM* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceImageProcessing2FeaturesQCOM(const PhysicalDeviceImageProcessing2FeaturesQCOM& copy_src);
+    PhysicalDeviceImageProcessing2FeaturesQCOM& operator=(const PhysicalDeviceImageProcessing2FeaturesQCOM& copy_src);
+    PhysicalDeviceImageProcessing2FeaturesQCOM();
+    ~PhysicalDeviceImageProcessing2FeaturesQCOM();
+    void initialize(const VkPhysicalDeviceImageProcessing2FeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageProcessing2FeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageProcessing2FeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceImageProcessing2FeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessing2FeaturesQCOM const*>(this);
+    }
+};
+struct PhysicalDeviceImageProcessing2PropertiesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D maxBlockMatchWindow;
+
+    PhysicalDeviceImageProcessing2PropertiesQCOM(const VkPhysicalDeviceImageProcessing2PropertiesQCOM* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceImageProcessing2PropertiesQCOM(const PhysicalDeviceImageProcessing2PropertiesQCOM& copy_src);
+    PhysicalDeviceImageProcessing2PropertiesQCOM& operator=(const PhysicalDeviceImageProcessing2PropertiesQCOM& copy_src);
+    PhysicalDeviceImageProcessing2PropertiesQCOM();
+    ~PhysicalDeviceImageProcessing2PropertiesQCOM();
+    void initialize(const VkPhysicalDeviceImageProcessing2PropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceImageProcessing2PropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageProcessing2PropertiesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessing2PropertiesQCOM*>(this);
+    }
+    VkPhysicalDeviceImageProcessing2PropertiesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessing2PropertiesQCOM const*>(this);
+    }
+};
+struct SamplerBlockMatchWindowCreateInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExtent2D windowExtent;
+    VkBlockMatchWindowCompareModeQCOM windowCompareMode;
+
+    SamplerBlockMatchWindowCreateInfoQCOM(const VkSamplerBlockMatchWindowCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    SamplerBlockMatchWindowCreateInfoQCOM(const SamplerBlockMatchWindowCreateInfoQCOM& copy_src);
+    SamplerBlockMatchWindowCreateInfoQCOM& operator=(const SamplerBlockMatchWindowCreateInfoQCOM& copy_src);
+    SamplerBlockMatchWindowCreateInfoQCOM();
+    ~SamplerBlockMatchWindowCreateInfoQCOM();
+    void initialize(const VkSamplerBlockMatchWindowCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SamplerBlockMatchWindowCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerBlockMatchWindowCreateInfoQCOM* ptr() { return reinterpret_cast<VkSamplerBlockMatchWindowCreateInfoQCOM*>(this); }
+    VkSamplerBlockMatchWindowCreateInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkSamplerBlockMatchWindowCreateInfoQCOM const*>(this);
+    }
+};
+struct PhysicalDeviceCubicWeightsFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 selectableCubicWeights;
+
+    PhysicalDeviceCubicWeightsFeaturesQCOM(const VkPhysicalDeviceCubicWeightsFeaturesQCOM* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceCubicWeightsFeaturesQCOM(const PhysicalDeviceCubicWeightsFeaturesQCOM& copy_src);
+    PhysicalDeviceCubicWeightsFeaturesQCOM& operator=(const PhysicalDeviceCubicWeightsFeaturesQCOM& copy_src);
+    PhysicalDeviceCubicWeightsFeaturesQCOM();
+    ~PhysicalDeviceCubicWeightsFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceCubicWeightsFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCubicWeightsFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCubicWeightsFeaturesQCOM* ptr() { return reinterpret_cast<VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(this); }
+    VkPhysicalDeviceCubicWeightsFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCubicWeightsFeaturesQCOM const*>(this);
+    }
+};
+struct SamplerCubicWeightsCreateInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCubicFilterWeightsQCOM cubicWeights;
+
+    SamplerCubicWeightsCreateInfoQCOM(const VkSamplerCubicWeightsCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    SamplerCubicWeightsCreateInfoQCOM(const SamplerCubicWeightsCreateInfoQCOM& copy_src);
+    SamplerCubicWeightsCreateInfoQCOM& operator=(const SamplerCubicWeightsCreateInfoQCOM& copy_src);
+    SamplerCubicWeightsCreateInfoQCOM();
+    ~SamplerCubicWeightsCreateInfoQCOM();
+    void initialize(const VkSamplerCubicWeightsCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SamplerCubicWeightsCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerCubicWeightsCreateInfoQCOM* ptr() { return reinterpret_cast<VkSamplerCubicWeightsCreateInfoQCOM*>(this); }
+    VkSamplerCubicWeightsCreateInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkSamplerCubicWeightsCreateInfoQCOM const*>(this);
+    }
+};
+struct BlitImageCubicWeightsInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCubicFilterWeightsQCOM cubicWeights;
+
+    BlitImageCubicWeightsInfoQCOM(const VkBlitImageCubicWeightsInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    BlitImageCubicWeightsInfoQCOM(const BlitImageCubicWeightsInfoQCOM& copy_src);
+    BlitImageCubicWeightsInfoQCOM& operator=(const BlitImageCubicWeightsInfoQCOM& copy_src);
+    BlitImageCubicWeightsInfoQCOM();
+    ~BlitImageCubicWeightsInfoQCOM();
+    void initialize(const VkBlitImageCubicWeightsInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const BlitImageCubicWeightsInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkBlitImageCubicWeightsInfoQCOM* ptr() { return reinterpret_cast<VkBlitImageCubicWeightsInfoQCOM*>(this); }
+    VkBlitImageCubicWeightsInfoQCOM const* ptr() const { return reinterpret_cast<VkBlitImageCubicWeightsInfoQCOM const*>(this); }
+};
+struct PhysicalDeviceYcbcrDegammaFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 ycbcrDegamma;
+
+    PhysicalDeviceYcbcrDegammaFeaturesQCOM(const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceYcbcrDegammaFeaturesQCOM(const PhysicalDeviceYcbcrDegammaFeaturesQCOM& copy_src);
+    PhysicalDeviceYcbcrDegammaFeaturesQCOM& operator=(const PhysicalDeviceYcbcrDegammaFeaturesQCOM& copy_src);
+    PhysicalDeviceYcbcrDegammaFeaturesQCOM();
+    ~PhysicalDeviceYcbcrDegammaFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceYcbcrDegammaFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* ptr() { return reinterpret_cast<VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(this); }
+    VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const*>(this);
+    }
+};
+struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 enableYDegamma;
+    VkBool32 enableCbCrDegamma;
+
+    SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(const SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& copy_src);
+    SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& operator=(const SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& copy_src);
+    SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM();
+    ~SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM();
+    void initialize(const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* ptr() {
+        return reinterpret_cast<VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM*>(this);
+    }
+    VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const*>(this);
+    }
+};
+struct PhysicalDeviceCubicClampFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cubicRangeClamp;
+
+    PhysicalDeviceCubicClampFeaturesQCOM(const VkPhysicalDeviceCubicClampFeaturesQCOM* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    PhysicalDeviceCubicClampFeaturesQCOM(const PhysicalDeviceCubicClampFeaturesQCOM& copy_src);
+    PhysicalDeviceCubicClampFeaturesQCOM& operator=(const PhysicalDeviceCubicClampFeaturesQCOM& copy_src);
+    PhysicalDeviceCubicClampFeaturesQCOM();
+    ~PhysicalDeviceCubicClampFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceCubicClampFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceCubicClampFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCubicClampFeaturesQCOM* ptr() { return reinterpret_cast<VkPhysicalDeviceCubicClampFeaturesQCOM*>(this); }
+    VkPhysicalDeviceCubicClampFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCubicClampFeaturesQCOM const*>(this);
+    }
+};
+struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 attachmentFeedbackLoopDynamicState;
+
+    PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+        const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+        const PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& copy_src);
+    PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& operator=(
+        const PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& copy_src);
+    PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT();
+    ~PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT();
+    void initialize(const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* in_struct,
+                    PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* 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 ScreenBufferPropertiesQNX {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize allocationSize;
+    uint32_t memoryTypeBits;
+
+    ScreenBufferPropertiesQNX(const VkScreenBufferPropertiesQNX* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    ScreenBufferPropertiesQNX(const ScreenBufferPropertiesQNX& copy_src);
+    ScreenBufferPropertiesQNX& operator=(const ScreenBufferPropertiesQNX& copy_src);
+    ScreenBufferPropertiesQNX();
+    ~ScreenBufferPropertiesQNX();
+    void initialize(const VkScreenBufferPropertiesQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ScreenBufferPropertiesQNX* copy_src, PNextCopyState* copy_state = {});
+    VkScreenBufferPropertiesQNX* ptr() { return reinterpret_cast<VkScreenBufferPropertiesQNX*>(this); }
+    VkScreenBufferPropertiesQNX const* ptr() const { return reinterpret_cast<VkScreenBufferPropertiesQNX const*>(this); }
+};
+struct ScreenBufferFormatPropertiesQNX {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat format;
+    uint64_t externalFormat;
+    uint64_t screenUsage;
+    VkFormatFeatureFlags formatFeatures;
+    VkComponentMapping samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion suggestedYcbcrModel;
+    VkSamplerYcbcrRange suggestedYcbcrRange;
+    VkChromaLocation suggestedXChromaOffset;
+    VkChromaLocation suggestedYChromaOffset;
+
+    ScreenBufferFormatPropertiesQNX(const VkScreenBufferFormatPropertiesQNX* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    ScreenBufferFormatPropertiesQNX(const ScreenBufferFormatPropertiesQNX& copy_src);
+    ScreenBufferFormatPropertiesQNX& operator=(const ScreenBufferFormatPropertiesQNX& copy_src);
+    ScreenBufferFormatPropertiesQNX();
+    ~ScreenBufferFormatPropertiesQNX();
+    void initialize(const VkScreenBufferFormatPropertiesQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ScreenBufferFormatPropertiesQNX* copy_src, PNextCopyState* copy_state = {});
+    VkScreenBufferFormatPropertiesQNX* ptr() { return reinterpret_cast<VkScreenBufferFormatPropertiesQNX*>(this); }
+    VkScreenBufferFormatPropertiesQNX const* ptr() const {
+        return reinterpret_cast<VkScreenBufferFormatPropertiesQNX const*>(this);
+    }
+};
+struct ImportScreenBufferInfoQNX {
+    VkStructureType sType;
+    const void* pNext{};
+    struct _screen_buffer* buffer{};
+
+    ImportScreenBufferInfoQNX(const VkImportScreenBufferInfoQNX* in_struct, PNextCopyState* copy_state = {},
+                              bool copy_pnext = true);
+    ImportScreenBufferInfoQNX(const ImportScreenBufferInfoQNX& copy_src);
+    ImportScreenBufferInfoQNX& operator=(const ImportScreenBufferInfoQNX& copy_src);
+    ImportScreenBufferInfoQNX();
+    ~ImportScreenBufferInfoQNX();
+    void initialize(const VkImportScreenBufferInfoQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ImportScreenBufferInfoQNX* copy_src, PNextCopyState* copy_state = {});
+    VkImportScreenBufferInfoQNX* ptr() { return reinterpret_cast<VkImportScreenBufferInfoQNX*>(this); }
+    VkImportScreenBufferInfoQNX const* ptr() const { return reinterpret_cast<VkImportScreenBufferInfoQNX const*>(this); }
+};
+struct ExternalFormatQNX {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t externalFormat;
+
+    ExternalFormatQNX(const VkExternalFormatQNX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    ExternalFormatQNX(const ExternalFormatQNX& copy_src);
+    ExternalFormatQNX& operator=(const ExternalFormatQNX& copy_src);
+    ExternalFormatQNX();
+    ~ExternalFormatQNX();
+    void initialize(const VkExternalFormatQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const ExternalFormatQNX* copy_src, PNextCopyState* copy_state = {});
+    VkExternalFormatQNX* ptr() { return reinterpret_cast<VkExternalFormatQNX*>(this); }
+    VkExternalFormatQNX const* ptr() const { return reinterpret_cast<VkExternalFormatQNX const*>(this); }
+};
+struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 screenBufferImport;
+
+    PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(const PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& copy_src);
+    PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& operator=(
+        const PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& copy_src);
+    PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX();
+    ~PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX();
+    void initialize(const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* 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 PhysicalDeviceLayeredDriverPropertiesMSFT {
+    VkStructureType sType;
+    void* pNext{};
+    VkLayeredDriverUnderlyingApiMSFT underlyingAPI;
+
+    PhysicalDeviceLayeredDriverPropertiesMSFT(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceLayeredDriverPropertiesMSFT(const PhysicalDeviceLayeredDriverPropertiesMSFT& copy_src);
+    PhysicalDeviceLayeredDriverPropertiesMSFT& operator=(const PhysicalDeviceLayeredDriverPropertiesMSFT& copy_src);
+    PhysicalDeviceLayeredDriverPropertiesMSFT();
+    ~PhysicalDeviceLayeredDriverPropertiesMSFT();
+    void initialize(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceLayeredDriverPropertiesMSFT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLayeredDriverPropertiesMSFT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLayeredDriverPropertiesMSFT*>(this);
+    }
+    VkPhysicalDeviceLayeredDriverPropertiesMSFT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLayeredDriverPropertiesMSFT const*>(this);
+    }
+};
+struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 descriptorPoolOverallocation;
+
+    PhysicalDeviceDescriptorPoolOverallocationFeaturesNV(const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceDescriptorPoolOverallocationFeaturesNV(const PhysicalDeviceDescriptorPoolOverallocationFeaturesNV& copy_src);
+    PhysicalDeviceDescriptorPoolOverallocationFeaturesNV& operator=(
+        const PhysicalDeviceDescriptorPoolOverallocationFeaturesNV& copy_src);
+    PhysicalDeviceDescriptorPoolOverallocationFeaturesNV();
+    ~PhysicalDeviceDescriptorPoolOverallocationFeaturesNV();
+    void initialize(const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceDescriptorPoolOverallocationFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceRawAccessChainsFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderRawAccessChains;
+
+    PhysicalDeviceRawAccessChainsFeaturesNV(const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRawAccessChainsFeaturesNV(const PhysicalDeviceRawAccessChainsFeaturesNV& copy_src);
+    PhysicalDeviceRawAccessChainsFeaturesNV& operator=(const PhysicalDeviceRawAccessChainsFeaturesNV& copy_src);
+    PhysicalDeviceRawAccessChainsFeaturesNV();
+    ~PhysicalDeviceRawAccessChainsFeaturesNV();
+    void initialize(const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRawAccessChainsFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRawAccessChainsFeaturesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceRawAccessChainsFeaturesNV*>(this); }
+    VkPhysicalDeviceRawAccessChainsFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRawAccessChainsFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderFloat16VectorAtomics;
+
+    PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(const PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& copy_src);
+    PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& operator=(const PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& copy_src);
+    PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV();
+    ~PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV();
+    void initialize(const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const*>(this);
+    }
+};
+struct PhysicalDeviceRayTracingValidationFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingValidation;
+
+    PhysicalDeviceRayTracingValidationFeaturesNV(const VkPhysicalDeviceRayTracingValidationFeaturesNV* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRayTracingValidationFeaturesNV(const PhysicalDeviceRayTracingValidationFeaturesNV& copy_src);
+    PhysicalDeviceRayTracingValidationFeaturesNV& operator=(const PhysicalDeviceRayTracingValidationFeaturesNV& copy_src);
+    PhysicalDeviceRayTracingValidationFeaturesNV();
+    ~PhysicalDeviceRayTracingValidationFeaturesNV();
+    void initialize(const VkPhysicalDeviceRayTracingValidationFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRayTracingValidationFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingValidationFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceRayTracingValidationFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV const*>(this);
+    }
+};
+struct AccelerationStructureGeometryTrianglesDataKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat vertexFormat;
+    DeviceOrHostAddressConstKHR vertexData;
+    VkDeviceSize vertexStride;
+    uint32_t maxVertex;
+    VkIndexType indexType;
+    DeviceOrHostAddressConstKHR indexData;
+    DeviceOrHostAddressConstKHR transformData;
+
+    AccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureGeometryTrianglesDataKHR(const AccelerationStructureGeometryTrianglesDataKHR& copy_src);
+    AccelerationStructureGeometryTrianglesDataKHR& operator=(const AccelerationStructureGeometryTrianglesDataKHR& copy_src);
+    AccelerationStructureGeometryTrianglesDataKHR();
+    ~AccelerationStructureGeometryTrianglesDataKHR();
+    void initialize(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureGeometryTrianglesDataKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometryTrianglesDataKHR* ptr() {
+        return reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR*>(this);
+    }
+    VkAccelerationStructureGeometryTrianglesDataKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR const*>(this);
+    }
+};
+struct AccelerationStructureGeometryAabbsDataKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    DeviceOrHostAddressConstKHR data;
+    VkDeviceSize stride;
+
+    AccelerationStructureGeometryAabbsDataKHR(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureGeometryAabbsDataKHR(const AccelerationStructureGeometryAabbsDataKHR& copy_src);
+    AccelerationStructureGeometryAabbsDataKHR& operator=(const AccelerationStructureGeometryAabbsDataKHR& copy_src);
+    AccelerationStructureGeometryAabbsDataKHR();
+    ~AccelerationStructureGeometryAabbsDataKHR();
+    void initialize(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureGeometryAabbsDataKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometryAabbsDataKHR* ptr() {
+        return reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR*>(this);
+    }
+    VkAccelerationStructureGeometryAabbsDataKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR const*>(this);
+    }
+};
+struct AccelerationStructureGeometryInstancesDataKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 arrayOfPointers;
+    DeviceOrHostAddressConstKHR data;
+
+    AccelerationStructureGeometryInstancesDataKHR(const VkAccelerationStructureGeometryInstancesDataKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureGeometryInstancesDataKHR(const AccelerationStructureGeometryInstancesDataKHR& copy_src);
+    AccelerationStructureGeometryInstancesDataKHR& operator=(const AccelerationStructureGeometryInstancesDataKHR& copy_src);
+    AccelerationStructureGeometryInstancesDataKHR();
+    ~AccelerationStructureGeometryInstancesDataKHR();
+    void initialize(const VkAccelerationStructureGeometryInstancesDataKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureGeometryInstancesDataKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometryInstancesDataKHR* ptr() {
+        return reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR*>(this);
+    }
+    VkAccelerationStructureGeometryInstancesDataKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR const*>(this);
+    }
+};
+struct AccelerationStructureGeometryKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkGeometryTypeKHR geometryType;
+    VkAccelerationStructureGeometryDataKHR geometry;
+    VkGeometryFlagsKHR flags;
+
+    AccelerationStructureGeometryKHR(const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host,
+                                     const VkAccelerationStructureBuildRangeInfoKHR* build_range_info,
+                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureGeometryKHR(const AccelerationStructureGeometryKHR& copy_src);
+    AccelerationStructureGeometryKHR& operator=(const AccelerationStructureGeometryKHR& copy_src);
+    AccelerationStructureGeometryKHR();
+    ~AccelerationStructureGeometryKHR();
+    void initialize(const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host,
+                    const VkAccelerationStructureBuildRangeInfoKHR* build_range_info, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureGeometryKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometryKHR* ptr() { return reinterpret_cast<VkAccelerationStructureGeometryKHR*>(this); }
+    VkAccelerationStructureGeometryKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometryKHR const*>(this);
+    }
+};
+struct AccelerationStructureBuildGeometryInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureTypeKHR type;
+    VkBuildAccelerationStructureFlagsKHR flags;
+    VkBuildAccelerationStructureModeKHR mode;
+    VkAccelerationStructureKHR srcAccelerationStructure;
+    VkAccelerationStructureKHR dstAccelerationStructure;
+    uint32_t geometryCount;
+    AccelerationStructureGeometryKHR* pGeometries{};
+    AccelerationStructureGeometryKHR** ppGeometries{};
+    DeviceOrHostAddressKHR scratchData;
+
+    AccelerationStructureBuildGeometryInfoKHR(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct, const bool is_host,
+                                              const VkAccelerationStructureBuildRangeInfoKHR* build_range_infos,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureBuildGeometryInfoKHR(const AccelerationStructureBuildGeometryInfoKHR& copy_src);
+    AccelerationStructureBuildGeometryInfoKHR& operator=(const AccelerationStructureBuildGeometryInfoKHR& copy_src);
+    AccelerationStructureBuildGeometryInfoKHR();
+    ~AccelerationStructureBuildGeometryInfoKHR();
+    void initialize(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct, const bool is_host,
+                    const VkAccelerationStructureBuildRangeInfoKHR* build_range_infos, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureBuildGeometryInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureBuildGeometryInfoKHR* ptr() {
+        return reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR*>(this);
+    }
+    VkAccelerationStructureBuildGeometryInfoKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR const*>(this);
+    }
+};
+struct AccelerationStructureCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureCreateFlagsKHR createFlags;
+    VkBuffer buffer;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+    VkAccelerationStructureTypeKHR type;
+    VkDeviceAddress deviceAddress;
+
+    AccelerationStructureCreateInfoKHR(const VkAccelerationStructureCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    AccelerationStructureCreateInfoKHR(const AccelerationStructureCreateInfoKHR& copy_src);
+    AccelerationStructureCreateInfoKHR& operator=(const AccelerationStructureCreateInfoKHR& copy_src);
+    AccelerationStructureCreateInfoKHR();
+    ~AccelerationStructureCreateInfoKHR();
+    void initialize(const VkAccelerationStructureCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureCreateInfoKHR* ptr() { return reinterpret_cast<VkAccelerationStructureCreateInfoKHR*>(this); }
+    VkAccelerationStructureCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureCreateInfoKHR const*>(this);
+    }
+};
+struct WriteDescriptorSetAccelerationStructureKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t accelerationStructureCount;
+    VkAccelerationStructureKHR* pAccelerationStructures{};
+
+    WriteDescriptorSetAccelerationStructureKHR(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    WriteDescriptorSetAccelerationStructureKHR(const WriteDescriptorSetAccelerationStructureKHR& copy_src);
+    WriteDescriptorSetAccelerationStructureKHR& operator=(const WriteDescriptorSetAccelerationStructureKHR& copy_src);
+    WriteDescriptorSetAccelerationStructureKHR();
+    ~WriteDescriptorSetAccelerationStructureKHR();
+    void initialize(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const WriteDescriptorSetAccelerationStructureKHR* copy_src, PNextCopyState* copy_state = {});
+    VkWriteDescriptorSetAccelerationStructureKHR* ptr() {
+        return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(this);
+    }
+    VkWriteDescriptorSetAccelerationStructureKHR const* ptr() const {
+        return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR const*>(this);
+    }
+};
+struct PhysicalDeviceAccelerationStructureFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 accelerationStructure;
+    VkBool32 accelerationStructureCaptureReplay;
+    VkBool32 accelerationStructureIndirectBuild;
+    VkBool32 accelerationStructureHostCommands;
+    VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind;
+
+    PhysicalDeviceAccelerationStructureFeaturesKHR(const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceAccelerationStructureFeaturesKHR(const PhysicalDeviceAccelerationStructureFeaturesKHR& copy_src);
+    PhysicalDeviceAccelerationStructureFeaturesKHR& operator=(const PhysicalDeviceAccelerationStructureFeaturesKHR& copy_src);
+    PhysicalDeviceAccelerationStructureFeaturesKHR();
+    ~PhysicalDeviceAccelerationStructureFeaturesKHR();
+    void initialize(const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceAccelerationStructureFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAccelerationStructureFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceAccelerationStructureFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceAccelerationStructurePropertiesKHR {
+    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;
+
+    PhysicalDeviceAccelerationStructurePropertiesKHR(const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceAccelerationStructurePropertiesKHR(const PhysicalDeviceAccelerationStructurePropertiesKHR& copy_src);
+    PhysicalDeviceAccelerationStructurePropertiesKHR& operator=(const PhysicalDeviceAccelerationStructurePropertiesKHR& copy_src);
+    PhysicalDeviceAccelerationStructurePropertiesKHR();
+    ~PhysicalDeviceAccelerationStructurePropertiesKHR();
+    void initialize(const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceAccelerationStructurePropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAccelerationStructurePropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceAccelerationStructurePropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR const*>(this);
+    }
+};
+struct AccelerationStructureDeviceAddressInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureKHR accelerationStructure;
+
+    AccelerationStructureDeviceAddressInfoKHR(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureDeviceAddressInfoKHR(const AccelerationStructureDeviceAddressInfoKHR& copy_src);
+    AccelerationStructureDeviceAddressInfoKHR& operator=(const AccelerationStructureDeviceAddressInfoKHR& copy_src);
+    AccelerationStructureDeviceAddressInfoKHR();
+    ~AccelerationStructureDeviceAddressInfoKHR();
+    void initialize(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureDeviceAddressInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureDeviceAddressInfoKHR* ptr() {
+        return reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR*>(this);
+    }
+    VkAccelerationStructureDeviceAddressInfoKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR const*>(this);
+    }
+};
+struct AccelerationStructureVersionInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const uint8_t* pVersionData{};
+
+    AccelerationStructureVersionInfoKHR(const VkAccelerationStructureVersionInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    AccelerationStructureVersionInfoKHR(const AccelerationStructureVersionInfoKHR& copy_src);
+    AccelerationStructureVersionInfoKHR& operator=(const AccelerationStructureVersionInfoKHR& copy_src);
+    AccelerationStructureVersionInfoKHR();
+    ~AccelerationStructureVersionInfoKHR();
+    void initialize(const VkAccelerationStructureVersionInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureVersionInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureVersionInfoKHR* ptr() { return reinterpret_cast<VkAccelerationStructureVersionInfoKHR*>(this); }
+    VkAccelerationStructureVersionInfoKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureVersionInfoKHR const*>(this);
+    }
+};
+struct CopyAccelerationStructureToMemoryInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureKHR src;
+    DeviceOrHostAddressKHR dst;
+    VkCopyAccelerationStructureModeKHR mode;
+
+    CopyAccelerationStructureToMemoryInfoKHR(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CopyAccelerationStructureToMemoryInfoKHR(const CopyAccelerationStructureToMemoryInfoKHR& copy_src);
+    CopyAccelerationStructureToMemoryInfoKHR& operator=(const CopyAccelerationStructureToMemoryInfoKHR& copy_src);
+    CopyAccelerationStructureToMemoryInfoKHR();
+    ~CopyAccelerationStructureToMemoryInfoKHR();
+    void initialize(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyAccelerationStructureToMemoryInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkCopyAccelerationStructureToMemoryInfoKHR* ptr() {
+        return reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR*>(this);
+    }
+    VkCopyAccelerationStructureToMemoryInfoKHR const* ptr() const {
+        return reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR const*>(this);
+    }
+};
+struct CopyMemoryToAccelerationStructureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    DeviceOrHostAddressConstKHR src;
+    VkAccelerationStructureKHR dst;
+    VkCopyAccelerationStructureModeKHR mode;
+
+    CopyMemoryToAccelerationStructureInfoKHR(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    CopyMemoryToAccelerationStructureInfoKHR(const CopyMemoryToAccelerationStructureInfoKHR& copy_src);
+    CopyMemoryToAccelerationStructureInfoKHR& operator=(const CopyMemoryToAccelerationStructureInfoKHR& copy_src);
+    CopyMemoryToAccelerationStructureInfoKHR();
+    ~CopyMemoryToAccelerationStructureInfoKHR();
+    void initialize(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyMemoryToAccelerationStructureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkCopyMemoryToAccelerationStructureInfoKHR* ptr() {
+        return reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR*>(this);
+    }
+    VkCopyMemoryToAccelerationStructureInfoKHR const* ptr() const {
+        return reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR const*>(this);
+    }
+};
+struct CopyAccelerationStructureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureKHR src;
+    VkAccelerationStructureKHR dst;
+    VkCopyAccelerationStructureModeKHR mode;
+
+    CopyAccelerationStructureInfoKHR(const VkCopyAccelerationStructureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    CopyAccelerationStructureInfoKHR(const CopyAccelerationStructureInfoKHR& copy_src);
+    CopyAccelerationStructureInfoKHR& operator=(const CopyAccelerationStructureInfoKHR& copy_src);
+    CopyAccelerationStructureInfoKHR();
+    ~CopyAccelerationStructureInfoKHR();
+    void initialize(const VkCopyAccelerationStructureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const CopyAccelerationStructureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkCopyAccelerationStructureInfoKHR* ptr() { return reinterpret_cast<VkCopyAccelerationStructureInfoKHR*>(this); }
+    VkCopyAccelerationStructureInfoKHR const* ptr() const {
+        return reinterpret_cast<VkCopyAccelerationStructureInfoKHR const*>(this);
+    }
+};
+struct AccelerationStructureBuildSizesInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize accelerationStructureSize;
+    VkDeviceSize updateScratchSize;
+    VkDeviceSize buildScratchSize;
+
+    AccelerationStructureBuildSizesInfoKHR(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
+                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    AccelerationStructureBuildSizesInfoKHR(const AccelerationStructureBuildSizesInfoKHR& copy_src);
+    AccelerationStructureBuildSizesInfoKHR& operator=(const AccelerationStructureBuildSizesInfoKHR& copy_src);
+    AccelerationStructureBuildSizesInfoKHR();
+    ~AccelerationStructureBuildSizesInfoKHR();
+    void initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const AccelerationStructureBuildSizesInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureBuildSizesInfoKHR* ptr() { return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR*>(this); }
+    VkAccelerationStructureBuildSizesInfoKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR const*>(this);
+    }
+};
+struct RayTracingShaderGroupCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRayTracingShaderGroupTypeKHR type;
+    uint32_t generalShader;
+    uint32_t closestHitShader;
+    uint32_t anyHitShader;
+    uint32_t intersectionShader;
+    const void* pShaderGroupCaptureReplayHandle{};
+
+    RayTracingShaderGroupCreateInfoKHR(const VkRayTracingShaderGroupCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    RayTracingShaderGroupCreateInfoKHR(const RayTracingShaderGroupCreateInfoKHR& copy_src);
+    RayTracingShaderGroupCreateInfoKHR& operator=(const RayTracingShaderGroupCreateInfoKHR& copy_src);
+    RayTracingShaderGroupCreateInfoKHR();
+    ~RayTracingShaderGroupCreateInfoKHR();
+    void initialize(const VkRayTracingShaderGroupCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RayTracingShaderGroupCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRayTracingShaderGroupCreateInfoKHR* ptr() { return reinterpret_cast<VkRayTracingShaderGroupCreateInfoKHR*>(this); }
+    VkRayTracingShaderGroupCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRayTracingShaderGroupCreateInfoKHR const*>(this);
+    }
+};
+struct RayTracingPipelineInterfaceCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxPipelineRayPayloadSize;
+    uint32_t maxPipelineRayHitAttributeSize;
+
+    RayTracingPipelineInterfaceCreateInfoKHR(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct,
+                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    RayTracingPipelineInterfaceCreateInfoKHR(const RayTracingPipelineInterfaceCreateInfoKHR& copy_src);
+    RayTracingPipelineInterfaceCreateInfoKHR& operator=(const RayTracingPipelineInterfaceCreateInfoKHR& copy_src);
+    RayTracingPipelineInterfaceCreateInfoKHR();
+    ~RayTracingPipelineInterfaceCreateInfoKHR();
+    void initialize(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RayTracingPipelineInterfaceCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRayTracingPipelineInterfaceCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkRayTracingPipelineInterfaceCreateInfoKHR*>(this);
+    }
+    VkRayTracingPipelineInterfaceCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRayTracingPipelineInterfaceCreateInfoKHR const*>(this);
+    }
+};
+struct RayTracingPipelineCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags flags;
+    uint32_t stageCount;
+    PipelineShaderStageCreateInfo* pStages{};
+    uint32_t groupCount;
+    RayTracingShaderGroupCreateInfoKHR* pGroups{};
+    uint32_t maxPipelineRayRecursionDepth;
+    PipelineLibraryCreateInfoKHR* pLibraryInfo{};
+    RayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface{};
+    PipelineDynamicStateCreateInfo* pDynamicState{};
+    VkPipelineLayout layout;
+    VkPipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+
+    RayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    RayTracingPipelineCreateInfoKHR(const RayTracingPipelineCreateInfoKHR& copy_src);
+    RayTracingPipelineCreateInfoKHR& operator=(const RayTracingPipelineCreateInfoKHR& copy_src);
+    RayTracingPipelineCreateInfoKHR();
+    ~RayTracingPipelineCreateInfoKHR();
+    void initialize(const VkRayTracingPipelineCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const RayTracingPipelineCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRayTracingPipelineCreateInfoKHR* ptr() { return reinterpret_cast<VkRayTracingPipelineCreateInfoKHR*>(this); }
+    VkRayTracingPipelineCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRayTracingPipelineCreateInfoKHR const*>(this);
+    }
+};
+struct PhysicalDeviceRayTracingPipelineFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingPipeline;
+    VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay;
+    VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+    VkBool32 rayTracingPipelineTraceRaysIndirect;
+    VkBool32 rayTraversalPrimitiveCulling;
+
+    PhysicalDeviceRayTracingPipelineFeaturesKHR(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRayTracingPipelineFeaturesKHR(const PhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src);
+    PhysicalDeviceRayTracingPipelineFeaturesKHR& operator=(const PhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src);
+    PhysicalDeviceRayTracingPipelineFeaturesKHR();
+    ~PhysicalDeviceRayTracingPipelineFeaturesKHR();
+    void initialize(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRayTracingPipelineFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingPipelineFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceRayTracingPipelineFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceRayTracingPipelinePropertiesKHR {
+    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;
+
+    PhysicalDeviceRayTracingPipelinePropertiesKHR(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    PhysicalDeviceRayTracingPipelinePropertiesKHR(const PhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src);
+    PhysicalDeviceRayTracingPipelinePropertiesKHR& operator=(const PhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src);
+    PhysicalDeviceRayTracingPipelinePropertiesKHR();
+    ~PhysicalDeviceRayTracingPipelinePropertiesKHR();
+    void initialize(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRayTracingPipelinePropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingPipelinePropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceRayTracingPipelinePropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceRayQueryFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayQuery;
+
+    PhysicalDeviceRayQueryFeaturesKHR(const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    PhysicalDeviceRayQueryFeaturesKHR(const PhysicalDeviceRayQueryFeaturesKHR& copy_src);
+    PhysicalDeviceRayQueryFeaturesKHR& operator=(const PhysicalDeviceRayQueryFeaturesKHR& copy_src);
+    PhysicalDeviceRayQueryFeaturesKHR();
+    ~PhysicalDeviceRayQueryFeaturesKHR();
+    void initialize(const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceRayQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayQueryFeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(this); }
+    VkPhysicalDeviceRayQueryFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR const*>(this);
+    }
+};
+struct PhysicalDeviceMeshShaderFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 taskShader;
+    VkBool32 meshShader;
+    VkBool32 multiviewMeshShader;
+    VkBool32 primitiveFragmentShadingRateMeshShader;
+    VkBool32 meshShaderQueries;
+
+    PhysicalDeviceMeshShaderFeaturesEXT(const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    PhysicalDeviceMeshShaderFeaturesEXT(const PhysicalDeviceMeshShaderFeaturesEXT& copy_src);
+    PhysicalDeviceMeshShaderFeaturesEXT& operator=(const PhysicalDeviceMeshShaderFeaturesEXT& copy_src);
+    PhysicalDeviceMeshShaderFeaturesEXT();
+    ~PhysicalDeviceMeshShaderFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMeshShaderFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMeshShaderFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(this); }
+    VkPhysicalDeviceMeshShaderFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT const*>(this);
+    }
+};
+struct PhysicalDeviceMeshShaderPropertiesEXT {
+    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;
+
+    PhysicalDeviceMeshShaderPropertiesEXT(const VkPhysicalDeviceMeshShaderPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    PhysicalDeviceMeshShaderPropertiesEXT(const PhysicalDeviceMeshShaderPropertiesEXT& copy_src);
+    PhysicalDeviceMeshShaderPropertiesEXT& operator=(const PhysicalDeviceMeshShaderPropertiesEXT& copy_src);
+    PhysicalDeviceMeshShaderPropertiesEXT();
+    ~PhysicalDeviceMeshShaderPropertiesEXT();
+    void initialize(const VkPhysicalDeviceMeshShaderPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const PhysicalDeviceMeshShaderPropertiesEXT* 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 RayTracingPipelineCreateInfoCommon : public RayTracingPipelineCreateInfoKHR {
+  public:
+    RayTracingPipelineCreateInfoCommon() : RayTracingPipelineCreateInfoKHR() {}
+    RayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoNV* pCreateInfo) : RayTracingPipelineCreateInfoKHR() {
+        initialize(pCreateInfo);
+    }
+    RayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoKHR* pCreateInfo)
+        : RayTracingPipelineCreateInfoKHR(pCreateInfo) {}
+
+    void initialize(const VkRayTracingPipelineCreateInfoNV* pCreateInfo);
+    void initialize(const VkRayTracingPipelineCreateInfoKHR* pCreateInfo);
+    uint32_t maxRecursionDepth = 0;  // NV specific
+};
+
+}  // namespace safe
+}  // namespace vku
+
+// NOLINTEND
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 6f4fe4c..c780eb3 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -903,12 +903,20 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX:
             return "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
             return "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         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
@@ -997,6 +1005,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR";
 #endif  // VK_ENABLE_BETA_EXTENSIONS
@@ -1593,8 +1603,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
             return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV";
 #endif  // VK_ENABLE_BETA_EXTENSIONS
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 @@ def __init__(self,
         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 @@ def applyExtensionDependency(self):
                             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 @@ def applyExtensionDependency(self):
 
                         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 @@ def applyExtensionDependency(self):
             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 @@ def endFile(self):
         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 @@ def endFile(self):
         # 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 @@ def 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':
@@ -463,7 +493,7 @@ def genGroup(self, groupinfo, groupName, alias):
         # 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 @@ def genGroup(self, groupinfo, groupName, alias):
                     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 @@ def generate(self):
 ''')
         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 @@ def generate(self):
 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 @@ def generate(self):
 ''')
 
         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 @@ def generate(self):
                 '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 @@ def generate(self):
         # 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 @@ def generate(self):
             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 @@ def generate(self):
     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..40247cf 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 is not 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 is not 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..ac00817
--- /dev/null
+++ b/scripts/generators/safe_struct_generator.py
@@ -0,0 +1,814 @@
+#!/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 vk_name[2:]
+
+    def generateHeader(self):
+        out = []
+        out.append('''
+            #pragma once
+            #include <vulkan/vulkan.h>
+            #include <cstdlib>
+            #include <algorithm>
+            #include <functional>
+
+            namespace vku {
+            namespace safe {
+
+            // 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);
+            \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 RayTracingPipelineCreateInfoCommon : public RayTracingPipelineCreateInfoKHR {
+                public:
+                    RayTracingPipelineCreateInfoCommon() : RayTracingPipelineCreateInfoKHR() {}
+                    RayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoNV *pCreateInfo)
+                        : RayTracingPipelineCreateInfoKHR() {
+                        initialize(pCreateInfo);
+                    }
+                    RayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoKHR *pCreateInfo)
+                        : RayTracingPipelineCreateInfoKHR(pCreateInfo) {}
+
+                    void initialize(const VkRayTracingPipelineCreateInfoNV *pCreateInfo);
+                    void initialize(const VkRayTracingPipelineCreateInfoKHR *pCreateInfo);
+                    uint32_t maxRecursionDepth = 0;  // NV specific
+                };
+                ''')
+        out.append('''
+            } // namespace safe
+            } // 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 {
+            namespace safe {
+            char *SafeStringCopy(const char *in_string) {
+                if (nullptr == in_string) return nullptr;
+                char* dest = new char[std::strlen(in_string) + 1];
+                return std::strcpy(dest, in_string);
+            }
+
+            ''')
+        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 == 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 == 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 safe
+            } // 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 {
+            namespace safe {
+            ''')
+
+        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 safe
+            } // 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 @@ def generate(self):
         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 @@ class InitStructHelper {
 #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/src/CMakeLists.txt b/src/CMakeLists.txt
index eb36009..6ba4db8 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -91,3 +91,4 @@ if (VUL_WERROR)
 endif()
 
 add_subdirectory(layer)
+add_subdirectory(vulkan)
diff --git a/src/vulkan/CMakeLists.txt b/src/vulkan/CMakeLists.txt
new file mode 100644
index 0000000..3d1143c
--- /dev/null
+++ b/src/vulkan/CMakeLists.txt
@@ -0,0 +1,26 @@
+# 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
+)
diff --git a/src/vulkan/vk_safe_struct_core.cpp b/src/vulkan/vk_safe_struct_core.cpp
new file mode 100644
index 0000000..4cc1bf5
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_core.cpp
@@ -0,0 +1,18519 @@
+// *** 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 {
+namespace safe {
+
+BufferMemoryBarrier::BufferMemoryBarrier(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);
+    }
+}
+
+BufferMemoryBarrier::BufferMemoryBarrier()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER),
+      pNext(nullptr),
+      srcAccessMask(),
+      dstAccessMask(),
+      srcQueueFamilyIndex(),
+      dstQueueFamilyIndex(),
+      buffer(),
+      offset(),
+      size() {}
+
+BufferMemoryBarrier::BufferMemoryBarrier(const BufferMemoryBarrier& 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);
+}
+
+BufferMemoryBarrier& BufferMemoryBarrier::operator=(const BufferMemoryBarrier& 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;
+}
+
+BufferMemoryBarrier::~BufferMemoryBarrier() { FreePnextChain(pNext); }
+
+void BufferMemoryBarrier::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 BufferMemoryBarrier::initialize(const BufferMemoryBarrier* 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);
+}
+
+ImageMemoryBarrier::ImageMemoryBarrier(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);
+    }
+}
+
+ImageMemoryBarrier::ImageMemoryBarrier()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER),
+      pNext(nullptr),
+      srcAccessMask(),
+      dstAccessMask(),
+      oldLayout(),
+      newLayout(),
+      srcQueueFamilyIndex(),
+      dstQueueFamilyIndex(),
+      image(),
+      subresourceRange() {}
+
+ImageMemoryBarrier::ImageMemoryBarrier(const ImageMemoryBarrier& 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);
+}
+
+ImageMemoryBarrier& ImageMemoryBarrier::operator=(const ImageMemoryBarrier& 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;
+}
+
+ImageMemoryBarrier::~ImageMemoryBarrier() { FreePnextChain(pNext); }
+
+void ImageMemoryBarrier::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 ImageMemoryBarrier::initialize(const ImageMemoryBarrier* 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);
+}
+
+MemoryBarrier::MemoryBarrier(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);
+    }
+}
+
+MemoryBarrier::MemoryBarrier() : sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER), pNext(nullptr), srcAccessMask(), dstAccessMask() {}
+
+MemoryBarrier::MemoryBarrier(const MemoryBarrier& copy_src) {
+    sType = copy_src.sType;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryBarrier& MemoryBarrier::operator=(const MemoryBarrier& 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;
+}
+
+MemoryBarrier::~MemoryBarrier() { FreePnextChain(pNext); }
+
+void MemoryBarrier::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 MemoryBarrier::initialize(const MemoryBarrier* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+AllocationCallbacks::AllocationCallbacks(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) {}
+
+AllocationCallbacks::AllocationCallbacks()
+    : pUserData(nullptr), pfnAllocation(), pfnReallocation(), pfnFree(), pfnInternalAllocation(), pfnInternalFree() {}
+
+AllocationCallbacks::AllocationCallbacks(const AllocationCallbacks& 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;
+}
+
+AllocationCallbacks& AllocationCallbacks::operator=(const AllocationCallbacks& 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;
+}
+
+AllocationCallbacks::~AllocationCallbacks() {}
+
+void AllocationCallbacks::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 AllocationCallbacks::initialize(const AllocationCallbacks* 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;
+}
+
+ApplicationInfo::ApplicationInfo(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);
+}
+
+ApplicationInfo::ApplicationInfo()
+    : sType(VK_STRUCTURE_TYPE_APPLICATION_INFO),
+      pNext(nullptr),
+      pApplicationName(nullptr),
+      applicationVersion(),
+      pEngineName(nullptr),
+      engineVersion(),
+      apiVersion() {}
+
+ApplicationInfo::ApplicationInfo(const ApplicationInfo& 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);
+}
+
+ApplicationInfo& ApplicationInfo::operator=(const ApplicationInfo& 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;
+}
+
+ApplicationInfo::~ApplicationInfo() {
+    if (pApplicationName) delete[] pApplicationName;
+    if (pEngineName) delete[] pEngineName;
+    FreePnextChain(pNext);
+}
+
+void ApplicationInfo::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 ApplicationInfo::initialize(const ApplicationInfo* 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);
+}
+
+InstanceCreateInfo::InstanceCreateInfo(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 ApplicationInfo(in_struct->pApplicationInfo);
+}
+
+InstanceCreateInfo::InstanceCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      pApplicationInfo(nullptr),
+      enabledLayerCount(),
+      ppEnabledLayerNames(nullptr),
+      enabledExtensionCount(),
+      ppEnabledExtensionNames(nullptr) {}
+
+InstanceCreateInfo::InstanceCreateInfo(const InstanceCreateInfo& 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 ApplicationInfo(*copy_src.pApplicationInfo);
+}
+
+InstanceCreateInfo& InstanceCreateInfo::operator=(const InstanceCreateInfo& 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 ApplicationInfo(*copy_src.pApplicationInfo);
+
+    return *this;
+}
+
+InstanceCreateInfo::~InstanceCreateInfo() {
+    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 InstanceCreateInfo::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 ApplicationInfo(in_struct->pApplicationInfo);
+}
+
+void InstanceCreateInfo::initialize(const InstanceCreateInfo* 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 ApplicationInfo(*copy_src->pApplicationInfo);
+}
+
+DeviceQueueCreateInfo::DeviceQueueCreateInfo(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);
+    }
+}
+
+DeviceQueueCreateInfo::DeviceQueueCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      queueFamilyIndex(),
+      queueCount(),
+      pQueuePriorities(nullptr) {}
+
+DeviceQueueCreateInfo::DeviceQueueCreateInfo(const DeviceQueueCreateInfo& 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);
+    }
+}
+
+DeviceQueueCreateInfo& DeviceQueueCreateInfo::operator=(const DeviceQueueCreateInfo& 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;
+}
+
+DeviceQueueCreateInfo::~DeviceQueueCreateInfo() {
+    if (pQueuePriorities) delete[] pQueuePriorities;
+    FreePnextChain(pNext);
+}
+
+void DeviceQueueCreateInfo::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 DeviceQueueCreateInfo::initialize(const DeviceQueueCreateInfo* 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);
+    }
+}
+
+DeviceCreateInfo::DeviceCreateInfo(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 DeviceQueueCreateInfo[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);
+    }
+}
+
+DeviceCreateInfo::DeviceCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      queueCreateInfoCount(),
+      pQueueCreateInfos(nullptr),
+      enabledLayerCount(),
+      ppEnabledLayerNames(nullptr),
+      enabledExtensionCount(),
+      ppEnabledExtensionNames(nullptr),
+      pEnabledFeatures(nullptr) {}
+
+DeviceCreateInfo::DeviceCreateInfo(const DeviceCreateInfo& 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 DeviceQueueCreateInfo[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);
+    }
+}
+
+DeviceCreateInfo& DeviceCreateInfo::operator=(const DeviceCreateInfo& 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 DeviceQueueCreateInfo[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;
+}
+
+DeviceCreateInfo::~DeviceCreateInfo() {
+    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 DeviceCreateInfo::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 DeviceQueueCreateInfo[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 DeviceCreateInfo::initialize(const DeviceCreateInfo* 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 DeviceQueueCreateInfo[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);
+    }
+}
+
+SubmitInfo::SubmitInfo(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];
+        }
+    }
+}
+
+SubmitInfo::SubmitInfo()
+    : sType(VK_STRUCTURE_TYPE_SUBMIT_INFO),
+      pNext(nullptr),
+      waitSemaphoreCount(),
+      pWaitSemaphores(nullptr),
+      pWaitDstStageMask(nullptr),
+      commandBufferCount(),
+      pCommandBuffers(nullptr),
+      signalSemaphoreCount(),
+      pSignalSemaphores(nullptr) {}
+
+SubmitInfo::SubmitInfo(const SubmitInfo& 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];
+        }
+    }
+}
+
+SubmitInfo& SubmitInfo::operator=(const SubmitInfo& 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;
+}
+
+SubmitInfo::~SubmitInfo() {
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pWaitDstStageMask) delete[] pWaitDstStageMask;
+    if (pCommandBuffers) delete[] pCommandBuffers;
+    if (pSignalSemaphores) delete[] pSignalSemaphores;
+    FreePnextChain(pNext);
+}
+
+void SubmitInfo::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 SubmitInfo::initialize(const SubmitInfo* 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];
+        }
+    }
+}
+
+MappedMemoryRange::MappedMemoryRange(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);
+    }
+}
+
+MappedMemoryRange::MappedMemoryRange() : sType(VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE), pNext(nullptr), memory(), offset(), size() {}
+
+MappedMemoryRange::MappedMemoryRange(const MappedMemoryRange& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MappedMemoryRange& MappedMemoryRange::operator=(const MappedMemoryRange& 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;
+}
+
+MappedMemoryRange::~MappedMemoryRange() { FreePnextChain(pNext); }
+
+void MappedMemoryRange::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 MappedMemoryRange::initialize(const MappedMemoryRange* 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);
+}
+
+MemoryAllocateInfo::MemoryAllocateInfo(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);
+    }
+}
+
+MemoryAllocateInfo::MemoryAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO), pNext(nullptr), allocationSize(), memoryTypeIndex() {}
+
+MemoryAllocateInfo::MemoryAllocateInfo(const MemoryAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    allocationSize = copy_src.allocationSize;
+    memoryTypeIndex = copy_src.memoryTypeIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryAllocateInfo& MemoryAllocateInfo::operator=(const MemoryAllocateInfo& 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;
+}
+
+MemoryAllocateInfo::~MemoryAllocateInfo() { FreePnextChain(pNext); }
+
+void MemoryAllocateInfo::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 MemoryAllocateInfo::initialize(const MemoryAllocateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    allocationSize = copy_src->allocationSize;
+    memoryTypeIndex = copy_src->memoryTypeIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SparseBufferMemoryBindInfo::SparseBufferMemoryBindInfo(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];
+        }
+    }
+}
+
+SparseBufferMemoryBindInfo::SparseBufferMemoryBindInfo() : buffer(), bindCount(), pBinds(nullptr) {}
+
+SparseBufferMemoryBindInfo::SparseBufferMemoryBindInfo(const SparseBufferMemoryBindInfo& 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];
+        }
+    }
+}
+
+SparseBufferMemoryBindInfo& SparseBufferMemoryBindInfo::operator=(const SparseBufferMemoryBindInfo& 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;
+}
+
+SparseBufferMemoryBindInfo::~SparseBufferMemoryBindInfo() {
+    if (pBinds) delete[] pBinds;
+}
+
+void SparseBufferMemoryBindInfo::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 SparseBufferMemoryBindInfo::initialize(const SparseBufferMemoryBindInfo* 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];
+        }
+    }
+}
+
+SparseImageOpaqueMemoryBindInfo::SparseImageOpaqueMemoryBindInfo(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];
+        }
+    }
+}
+
+SparseImageOpaqueMemoryBindInfo::SparseImageOpaqueMemoryBindInfo() : image(), bindCount(), pBinds(nullptr) {}
+
+SparseImageOpaqueMemoryBindInfo::SparseImageOpaqueMemoryBindInfo(const SparseImageOpaqueMemoryBindInfo& 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];
+        }
+    }
+}
+
+SparseImageOpaqueMemoryBindInfo& SparseImageOpaqueMemoryBindInfo::operator=(const SparseImageOpaqueMemoryBindInfo& 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;
+}
+
+SparseImageOpaqueMemoryBindInfo::~SparseImageOpaqueMemoryBindInfo() {
+    if (pBinds) delete[] pBinds;
+}
+
+void SparseImageOpaqueMemoryBindInfo::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 SparseImageOpaqueMemoryBindInfo::initialize(const SparseImageOpaqueMemoryBindInfo* 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];
+        }
+    }
+}
+
+SparseImageMemoryBindInfo::SparseImageMemoryBindInfo(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];
+        }
+    }
+}
+
+SparseImageMemoryBindInfo::SparseImageMemoryBindInfo() : image(), bindCount(), pBinds(nullptr) {}
+
+SparseImageMemoryBindInfo::SparseImageMemoryBindInfo(const SparseImageMemoryBindInfo& 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];
+        }
+    }
+}
+
+SparseImageMemoryBindInfo& SparseImageMemoryBindInfo::operator=(const SparseImageMemoryBindInfo& 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;
+}
+
+SparseImageMemoryBindInfo::~SparseImageMemoryBindInfo() {
+    if (pBinds) delete[] pBinds;
+}
+
+void SparseImageMemoryBindInfo::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 SparseImageMemoryBindInfo::initialize(const SparseImageMemoryBindInfo* 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];
+        }
+    }
+}
+
+BindSparseInfo::BindSparseInfo(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 SparseBufferMemoryBindInfo[bufferBindCount];
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
+            pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]);
+        }
+    }
+    if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) {
+        pImageOpaqueBinds = new SparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
+            pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]);
+        }
+    }
+    if (imageBindCount && in_struct->pImageBinds) {
+        pImageBinds = new SparseImageMemoryBindInfo[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];
+        }
+    }
+}
+
+BindSparseInfo::BindSparseInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_SPARSE_INFO),
+      pNext(nullptr),
+      waitSemaphoreCount(),
+      pWaitSemaphores(nullptr),
+      bufferBindCount(),
+      pBufferBinds(nullptr),
+      imageOpaqueBindCount(),
+      pImageOpaqueBinds(nullptr),
+      imageBindCount(),
+      pImageBinds(nullptr),
+      signalSemaphoreCount(),
+      pSignalSemaphores(nullptr) {}
+
+BindSparseInfo::BindSparseInfo(const BindSparseInfo& 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 SparseBufferMemoryBindInfo[bufferBindCount];
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
+            pBufferBinds[i].initialize(&copy_src.pBufferBinds[i]);
+        }
+    }
+    if (imageOpaqueBindCount && copy_src.pImageOpaqueBinds) {
+        pImageOpaqueBinds = new SparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
+            pImageOpaqueBinds[i].initialize(&copy_src.pImageOpaqueBinds[i]);
+        }
+    }
+    if (imageBindCount && copy_src.pImageBinds) {
+        pImageBinds = new SparseImageMemoryBindInfo[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];
+        }
+    }
+}
+
+BindSparseInfo& BindSparseInfo::operator=(const BindSparseInfo& 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 SparseBufferMemoryBindInfo[bufferBindCount];
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
+            pBufferBinds[i].initialize(&copy_src.pBufferBinds[i]);
+        }
+    }
+    if (imageOpaqueBindCount && copy_src.pImageOpaqueBinds) {
+        pImageOpaqueBinds = new SparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
+            pImageOpaqueBinds[i].initialize(&copy_src.pImageOpaqueBinds[i]);
+        }
+    }
+    if (imageBindCount && copy_src.pImageBinds) {
+        pImageBinds = new SparseImageMemoryBindInfo[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;
+}
+
+BindSparseInfo::~BindSparseInfo() {
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pBufferBinds) delete[] pBufferBinds;
+    if (pImageOpaqueBinds) delete[] pImageOpaqueBinds;
+    if (pImageBinds) delete[] pImageBinds;
+    if (pSignalSemaphores) delete[] pSignalSemaphores;
+    FreePnextChain(pNext);
+}
+
+void BindSparseInfo::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 SparseBufferMemoryBindInfo[bufferBindCount];
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
+            pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]);
+        }
+    }
+    if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) {
+        pImageOpaqueBinds = new SparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
+            pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]);
+        }
+    }
+    if (imageBindCount && in_struct->pImageBinds) {
+        pImageBinds = new SparseImageMemoryBindInfo[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 BindSparseInfo::initialize(const BindSparseInfo* 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 SparseBufferMemoryBindInfo[bufferBindCount];
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
+            pBufferBinds[i].initialize(&copy_src->pBufferBinds[i]);
+        }
+    }
+    if (imageOpaqueBindCount && copy_src->pImageOpaqueBinds) {
+        pImageOpaqueBinds = new SparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
+            pImageOpaqueBinds[i].initialize(&copy_src->pImageOpaqueBinds[i]);
+        }
+    }
+    if (imageBindCount && copy_src->pImageBinds) {
+        pImageBinds = new SparseImageMemoryBindInfo[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];
+        }
+    }
+}
+
+FenceCreateInfo::FenceCreateInfo(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);
+    }
+}
+
+FenceCreateInfo::FenceCreateInfo() : sType(VK_STRUCTURE_TYPE_FENCE_CREATE_INFO), pNext(nullptr), flags() {}
+
+FenceCreateInfo::FenceCreateInfo(const FenceCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+FenceCreateInfo& FenceCreateInfo::operator=(const FenceCreateInfo& 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;
+}
+
+FenceCreateInfo::~FenceCreateInfo() { FreePnextChain(pNext); }
+
+void FenceCreateInfo::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 FenceCreateInfo::initialize(const FenceCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SemaphoreCreateInfo::SemaphoreCreateInfo(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);
+    }
+}
+
+SemaphoreCreateInfo::SemaphoreCreateInfo() : sType(VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO), pNext(nullptr), flags() {}
+
+SemaphoreCreateInfo::SemaphoreCreateInfo(const SemaphoreCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SemaphoreCreateInfo& SemaphoreCreateInfo::operator=(const SemaphoreCreateInfo& 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;
+}
+
+SemaphoreCreateInfo::~SemaphoreCreateInfo() { FreePnextChain(pNext); }
+
+void SemaphoreCreateInfo::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 SemaphoreCreateInfo::initialize(const SemaphoreCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+EventCreateInfo::EventCreateInfo(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);
+    }
+}
+
+EventCreateInfo::EventCreateInfo() : sType(VK_STRUCTURE_TYPE_EVENT_CREATE_INFO), pNext(nullptr), flags() {}
+
+EventCreateInfo::EventCreateInfo(const EventCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+EventCreateInfo& EventCreateInfo::operator=(const EventCreateInfo& 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;
+}
+
+EventCreateInfo::~EventCreateInfo() { FreePnextChain(pNext); }
+
+void EventCreateInfo::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 EventCreateInfo::initialize(const EventCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+QueryPoolCreateInfo::QueryPoolCreateInfo(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);
+    }
+}
+
+QueryPoolCreateInfo::QueryPoolCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO), pNext(nullptr), flags(), queryType(), queryCount(), pipelineStatistics() {}
+
+QueryPoolCreateInfo::QueryPoolCreateInfo(const QueryPoolCreateInfo& 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);
+}
+
+QueryPoolCreateInfo& QueryPoolCreateInfo::operator=(const QueryPoolCreateInfo& 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;
+}
+
+QueryPoolCreateInfo::~QueryPoolCreateInfo() { FreePnextChain(pNext); }
+
+void QueryPoolCreateInfo::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 QueryPoolCreateInfo::initialize(const QueryPoolCreateInfo* 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);
+}
+
+BufferCreateInfo::BufferCreateInfo(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;
+    }
+}
+
+BufferCreateInfo::BufferCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      size(),
+      usage(),
+      sharingMode(),
+      queueFamilyIndexCount(),
+      pQueueFamilyIndices(nullptr) {}
+
+BufferCreateInfo::BufferCreateInfo(const BufferCreateInfo& 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;
+    }
+}
+
+BufferCreateInfo& BufferCreateInfo::operator=(const BufferCreateInfo& 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;
+}
+
+BufferCreateInfo::~BufferCreateInfo() {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+}
+
+void BufferCreateInfo::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 BufferCreateInfo::initialize(const BufferCreateInfo* 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;
+    }
+}
+
+BufferViewCreateInfo::BufferViewCreateInfo(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);
+    }
+}
+
+BufferViewCreateInfo::BufferViewCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO), pNext(nullptr), flags(), buffer(), format(), offset(), range() {}
+
+BufferViewCreateInfo::BufferViewCreateInfo(const BufferViewCreateInfo& 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);
+}
+
+BufferViewCreateInfo& BufferViewCreateInfo::operator=(const BufferViewCreateInfo& 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;
+}
+
+BufferViewCreateInfo::~BufferViewCreateInfo() { FreePnextChain(pNext); }
+
+void BufferViewCreateInfo::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 BufferViewCreateInfo::initialize(const BufferViewCreateInfo* 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);
+}
+
+ImageCreateInfo::ImageCreateInfo(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;
+    }
+}
+
+ImageCreateInfo::ImageCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      imageType(),
+      format(),
+      extent(),
+      mipLevels(),
+      arrayLayers(),
+      samples(),
+      tiling(),
+      usage(),
+      sharingMode(),
+      queueFamilyIndexCount(),
+      pQueueFamilyIndices(nullptr),
+      initialLayout() {}
+
+ImageCreateInfo::ImageCreateInfo(const ImageCreateInfo& 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;
+    }
+}
+
+ImageCreateInfo& ImageCreateInfo::operator=(const ImageCreateInfo& 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;
+}
+
+ImageCreateInfo::~ImageCreateInfo() {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+}
+
+void ImageCreateInfo::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 ImageCreateInfo::initialize(const ImageCreateInfo* 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;
+    }
+}
+
+ImageViewCreateInfo::ImageViewCreateInfo(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);
+    }
+}
+
+ImageViewCreateInfo::ImageViewCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      image(),
+      viewType(),
+      format(),
+      components(),
+      subresourceRange() {}
+
+ImageViewCreateInfo::ImageViewCreateInfo(const ImageViewCreateInfo& 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);
+}
+
+ImageViewCreateInfo& ImageViewCreateInfo::operator=(const ImageViewCreateInfo& 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;
+}
+
+ImageViewCreateInfo::~ImageViewCreateInfo() { FreePnextChain(pNext); }
+
+void ImageViewCreateInfo::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 ImageViewCreateInfo::initialize(const ImageViewCreateInfo* 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);
+}
+
+ShaderModuleCreateInfo::ShaderModuleCreateInfo(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);
+    }
+}
+
+ShaderModuleCreateInfo::ShaderModuleCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO), pNext(nullptr), flags(), codeSize(), pCode(nullptr) {}
+
+ShaderModuleCreateInfo::ShaderModuleCreateInfo(const ShaderModuleCreateInfo& 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);
+    }
+}
+
+ShaderModuleCreateInfo& ShaderModuleCreateInfo::operator=(const ShaderModuleCreateInfo& 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;
+}
+
+ShaderModuleCreateInfo::~ShaderModuleCreateInfo() {
+    if (pCode) delete[] reinterpret_cast<const uint8_t*>(pCode);
+    FreePnextChain(pNext);
+}
+
+void ShaderModuleCreateInfo::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 ShaderModuleCreateInfo::initialize(const ShaderModuleCreateInfo* 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);
+    }
+}
+
+PipelineCacheCreateInfo::PipelineCacheCreateInfo(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);
+    }
+}
+
+PipelineCacheCreateInfo::PipelineCacheCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO), pNext(nullptr), flags(), initialDataSize(), pInitialData(nullptr) {}
+
+PipelineCacheCreateInfo::PipelineCacheCreateInfo(const PipelineCacheCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    initialDataSize = copy_src.initialDataSize;
+    pInitialData = copy_src.pInitialData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineCacheCreateInfo& PipelineCacheCreateInfo::operator=(const PipelineCacheCreateInfo& 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;
+}
+
+PipelineCacheCreateInfo::~PipelineCacheCreateInfo() { FreePnextChain(pNext); }
+
+void PipelineCacheCreateInfo::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 PipelineCacheCreateInfo::initialize(const PipelineCacheCreateInfo* 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);
+}
+
+SpecializationInfo::SpecializationInfo(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;
+    }
+}
+
+SpecializationInfo::SpecializationInfo() : mapEntryCount(), pMapEntries(nullptr), dataSize(), pData(nullptr) {}
+
+SpecializationInfo::SpecializationInfo(const SpecializationInfo& 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;
+    }
+}
+
+SpecializationInfo& SpecializationInfo::operator=(const SpecializationInfo& 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;
+}
+
+SpecializationInfo::~SpecializationInfo() {
+    if (pMapEntries) delete[] pMapEntries;
+
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+}
+
+void SpecializationInfo::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 SpecializationInfo::initialize(const SpecializationInfo* 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;
+    }
+}
+
+PipelineShaderStageCreateInfo::PipelineShaderStageCreateInfo(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 SpecializationInfo(in_struct->pSpecializationInfo);
+}
+
+PipelineShaderStageCreateInfo::PipelineShaderStageCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      stage(),
+      module(),
+      pName(nullptr),
+      pSpecializationInfo(nullptr) {}
+
+PipelineShaderStageCreateInfo::PipelineShaderStageCreateInfo(const PipelineShaderStageCreateInfo& 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 SpecializationInfo(*copy_src.pSpecializationInfo);
+}
+
+PipelineShaderStageCreateInfo& PipelineShaderStageCreateInfo::operator=(const PipelineShaderStageCreateInfo& 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 SpecializationInfo(*copy_src.pSpecializationInfo);
+
+    return *this;
+}
+
+PipelineShaderStageCreateInfo::~PipelineShaderStageCreateInfo() {
+    if (pName) delete[] pName;
+    if (pSpecializationInfo) delete pSpecializationInfo;
+    FreePnextChain(pNext);
+}
+
+void PipelineShaderStageCreateInfo::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 SpecializationInfo(in_struct->pSpecializationInfo);
+}
+
+void PipelineShaderStageCreateInfo::initialize(const PipelineShaderStageCreateInfo* 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 SpecializationInfo(*copy_src->pSpecializationInfo);
+}
+
+ComputePipelineCreateInfo::ComputePipelineCreateInfo(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);
+    }
+}
+
+ComputePipelineCreateInfo::ComputePipelineCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      layout(),
+      basePipelineHandle(),
+      basePipelineIndex() {}
+
+ComputePipelineCreateInfo::ComputePipelineCreateInfo(const ComputePipelineCreateInfo& 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);
+}
+
+ComputePipelineCreateInfo& ComputePipelineCreateInfo::operator=(const ComputePipelineCreateInfo& 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;
+}
+
+ComputePipelineCreateInfo::~ComputePipelineCreateInfo() { FreePnextChain(pNext); }
+
+void ComputePipelineCreateInfo::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 ComputePipelineCreateInfo::initialize(const ComputePipelineCreateInfo* 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);
+}
+
+PipelineVertexInputStateCreateInfo::PipelineVertexInputStateCreateInfo(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);
+    }
+}
+
+PipelineVertexInputStateCreateInfo::PipelineVertexInputStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      vertexBindingDescriptionCount(),
+      pVertexBindingDescriptions(nullptr),
+      vertexAttributeDescriptionCount(),
+      pVertexAttributeDescriptions(nullptr) {}
+
+PipelineVertexInputStateCreateInfo::PipelineVertexInputStateCreateInfo(const PipelineVertexInputStateCreateInfo& 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);
+    }
+}
+
+PipelineVertexInputStateCreateInfo& PipelineVertexInputStateCreateInfo::operator=(
+    const PipelineVertexInputStateCreateInfo& 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;
+}
+
+PipelineVertexInputStateCreateInfo::~PipelineVertexInputStateCreateInfo() {
+    if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions;
+    if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions;
+    FreePnextChain(pNext);
+}
+
+void PipelineVertexInputStateCreateInfo::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 PipelineVertexInputStateCreateInfo::initialize(const PipelineVertexInputStateCreateInfo* 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);
+    }
+}
+
+PipelineInputAssemblyStateCreateInfo::PipelineInputAssemblyStateCreateInfo(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);
+    }
+}
+
+PipelineInputAssemblyStateCreateInfo::PipelineInputAssemblyStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      topology(),
+      primitiveRestartEnable() {}
+
+PipelineInputAssemblyStateCreateInfo::PipelineInputAssemblyStateCreateInfo(const PipelineInputAssemblyStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    topology = copy_src.topology;
+    primitiveRestartEnable = copy_src.primitiveRestartEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineInputAssemblyStateCreateInfo& PipelineInputAssemblyStateCreateInfo::operator=(
+    const PipelineInputAssemblyStateCreateInfo& 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;
+}
+
+PipelineInputAssemblyStateCreateInfo::~PipelineInputAssemblyStateCreateInfo() { FreePnextChain(pNext); }
+
+void PipelineInputAssemblyStateCreateInfo::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 PipelineInputAssemblyStateCreateInfo::initialize(const PipelineInputAssemblyStateCreateInfo* 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);
+}
+
+PipelineTessellationStateCreateInfo::PipelineTessellationStateCreateInfo(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);
+    }
+}
+
+PipelineTessellationStateCreateInfo::PipelineTessellationStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO), pNext(nullptr), flags(), patchControlPoints() {}
+
+PipelineTessellationStateCreateInfo::PipelineTessellationStateCreateInfo(const PipelineTessellationStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    patchControlPoints = copy_src.patchControlPoints;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineTessellationStateCreateInfo& PipelineTessellationStateCreateInfo::operator=(
+    const PipelineTessellationStateCreateInfo& 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;
+}
+
+PipelineTessellationStateCreateInfo::~PipelineTessellationStateCreateInfo() { FreePnextChain(pNext); }
+
+void PipelineTessellationStateCreateInfo::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 PipelineTessellationStateCreateInfo::initialize(const PipelineTessellationStateCreateInfo* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    patchControlPoints = copy_src->patchControlPoints;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineRasterizationStateCreateInfo::PipelineRasterizationStateCreateInfo(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);
+    }
+}
+
+PipelineRasterizationStateCreateInfo::PipelineRasterizationStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      depthClampEnable(),
+      rasterizerDiscardEnable(),
+      polygonMode(),
+      cullMode(),
+      frontFace(),
+      depthBiasEnable(),
+      depthBiasConstantFactor(),
+      depthBiasClamp(),
+      depthBiasSlopeFactor(),
+      lineWidth() {}
+
+PipelineRasterizationStateCreateInfo::PipelineRasterizationStateCreateInfo(const PipelineRasterizationStateCreateInfo& 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);
+}
+
+PipelineRasterizationStateCreateInfo& PipelineRasterizationStateCreateInfo::operator=(
+    const PipelineRasterizationStateCreateInfo& 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;
+}
+
+PipelineRasterizationStateCreateInfo::~PipelineRasterizationStateCreateInfo() { FreePnextChain(pNext); }
+
+void PipelineRasterizationStateCreateInfo::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 PipelineRasterizationStateCreateInfo::initialize(const PipelineRasterizationStateCreateInfo* 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);
+}
+
+PipelineMultisampleStateCreateInfo::PipelineMultisampleStateCreateInfo(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);
+    }
+}
+
+PipelineMultisampleStateCreateInfo::PipelineMultisampleStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      rasterizationSamples(),
+      sampleShadingEnable(),
+      minSampleShading(),
+      pSampleMask(nullptr),
+      alphaToCoverageEnable(),
+      alphaToOneEnable() {}
+
+PipelineMultisampleStateCreateInfo::PipelineMultisampleStateCreateInfo(const PipelineMultisampleStateCreateInfo& 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);
+    }
+}
+
+PipelineMultisampleStateCreateInfo& PipelineMultisampleStateCreateInfo::operator=(
+    const PipelineMultisampleStateCreateInfo& 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;
+}
+
+PipelineMultisampleStateCreateInfo::~PipelineMultisampleStateCreateInfo() {
+    if (pSampleMask) delete pSampleMask;
+    FreePnextChain(pNext);
+}
+
+void PipelineMultisampleStateCreateInfo::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 PipelineMultisampleStateCreateInfo::initialize(const PipelineMultisampleStateCreateInfo* 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);
+    }
+}
+
+PipelineDepthStencilStateCreateInfo::PipelineDepthStencilStateCreateInfo(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);
+    }
+}
+
+PipelineDepthStencilStateCreateInfo::PipelineDepthStencilStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      depthTestEnable(),
+      depthWriteEnable(),
+      depthCompareOp(),
+      depthBoundsTestEnable(),
+      stencilTestEnable(),
+      front(),
+      back(),
+      minDepthBounds(),
+      maxDepthBounds() {}
+
+PipelineDepthStencilStateCreateInfo::PipelineDepthStencilStateCreateInfo(const PipelineDepthStencilStateCreateInfo& 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);
+}
+
+PipelineDepthStencilStateCreateInfo& PipelineDepthStencilStateCreateInfo::operator=(
+    const PipelineDepthStencilStateCreateInfo& 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;
+}
+
+PipelineDepthStencilStateCreateInfo::~PipelineDepthStencilStateCreateInfo() { FreePnextChain(pNext); }
+
+void PipelineDepthStencilStateCreateInfo::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 PipelineDepthStencilStateCreateInfo::initialize(const PipelineDepthStencilStateCreateInfo* 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);
+}
+
+PipelineColorBlendStateCreateInfo::PipelineColorBlendStateCreateInfo(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];
+    }
+}
+
+PipelineColorBlendStateCreateInfo::PipelineColorBlendStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      logicOpEnable(),
+      logicOp(),
+      attachmentCount(),
+      pAttachments(nullptr) {}
+
+PipelineColorBlendStateCreateInfo::PipelineColorBlendStateCreateInfo(const PipelineColorBlendStateCreateInfo& 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];
+    }
+}
+
+PipelineColorBlendStateCreateInfo& PipelineColorBlendStateCreateInfo::operator=(const PipelineColorBlendStateCreateInfo& 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;
+}
+
+PipelineColorBlendStateCreateInfo::~PipelineColorBlendStateCreateInfo() {
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+}
+
+void PipelineColorBlendStateCreateInfo::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 PipelineColorBlendStateCreateInfo::initialize(const PipelineColorBlendStateCreateInfo* 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];
+    }
+}
+
+PipelineDynamicStateCreateInfo::PipelineDynamicStateCreateInfo(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);
+    }
+}
+
+PipelineDynamicStateCreateInfo::PipelineDynamicStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      dynamicStateCount(),
+      pDynamicStates(nullptr) {}
+
+PipelineDynamicStateCreateInfo::PipelineDynamicStateCreateInfo(const PipelineDynamicStateCreateInfo& 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);
+    }
+}
+
+PipelineDynamicStateCreateInfo& PipelineDynamicStateCreateInfo::operator=(const PipelineDynamicStateCreateInfo& 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;
+}
+
+PipelineDynamicStateCreateInfo::~PipelineDynamicStateCreateInfo() {
+    if (pDynamicStates) delete[] pDynamicStates;
+    FreePnextChain(pNext);
+}
+
+void PipelineDynamicStateCreateInfo::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 PipelineDynamicStateCreateInfo::initialize(const PipelineDynamicStateCreateInfo* 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);
+    }
+}
+
+PipelineLayoutCreateInfo::PipelineLayoutCreateInfo(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);
+    }
+}
+
+PipelineLayoutCreateInfo::PipelineLayoutCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      setLayoutCount(),
+      pSetLayouts(nullptr),
+      pushConstantRangeCount(),
+      pPushConstantRanges(nullptr) {}
+
+PipelineLayoutCreateInfo::PipelineLayoutCreateInfo(const PipelineLayoutCreateInfo& 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);
+    }
+}
+
+PipelineLayoutCreateInfo& PipelineLayoutCreateInfo::operator=(const PipelineLayoutCreateInfo& 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;
+}
+
+PipelineLayoutCreateInfo::~PipelineLayoutCreateInfo() {
+    if (pSetLayouts) delete[] pSetLayouts;
+    if (pPushConstantRanges) delete[] pPushConstantRanges;
+    FreePnextChain(pNext);
+}
+
+void PipelineLayoutCreateInfo::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 PipelineLayoutCreateInfo::initialize(const PipelineLayoutCreateInfo* 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);
+    }
+}
+
+SamplerCreateInfo::SamplerCreateInfo(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);
+    }
+}
+
+SamplerCreateInfo::SamplerCreateInfo()
+    : 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() {}
+
+SamplerCreateInfo::SamplerCreateInfo(const SamplerCreateInfo& 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);
+}
+
+SamplerCreateInfo& SamplerCreateInfo::operator=(const SamplerCreateInfo& 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;
+}
+
+SamplerCreateInfo::~SamplerCreateInfo() { FreePnextChain(pNext); }
+
+void SamplerCreateInfo::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 SamplerCreateInfo::initialize(const SamplerCreateInfo* 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);
+}
+
+CopyDescriptorSet::CopyDescriptorSet(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);
+    }
+}
+
+CopyDescriptorSet::CopyDescriptorSet()
+    : sType(VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET),
+      pNext(nullptr),
+      srcSet(),
+      srcBinding(),
+      srcArrayElement(),
+      dstSet(),
+      dstBinding(),
+      dstArrayElement(),
+      descriptorCount() {}
+
+CopyDescriptorSet::CopyDescriptorSet(const CopyDescriptorSet& 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);
+}
+
+CopyDescriptorSet& CopyDescriptorSet::operator=(const CopyDescriptorSet& 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;
+}
+
+CopyDescriptorSet::~CopyDescriptorSet() { FreePnextChain(pNext); }
+
+void CopyDescriptorSet::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 CopyDescriptorSet::initialize(const CopyDescriptorSet* 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);
+}
+
+DescriptorPoolCreateInfo::DescriptorPoolCreateInfo(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);
+    }
+}
+
+DescriptorPoolCreateInfo::DescriptorPoolCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      maxSets(),
+      poolSizeCount(),
+      pPoolSizes(nullptr) {}
+
+DescriptorPoolCreateInfo::DescriptorPoolCreateInfo(const DescriptorPoolCreateInfo& 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);
+    }
+}
+
+DescriptorPoolCreateInfo& DescriptorPoolCreateInfo::operator=(const DescriptorPoolCreateInfo& 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;
+}
+
+DescriptorPoolCreateInfo::~DescriptorPoolCreateInfo() {
+    if (pPoolSizes) delete[] pPoolSizes;
+    FreePnextChain(pNext);
+}
+
+void DescriptorPoolCreateInfo::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 DescriptorPoolCreateInfo::initialize(const DescriptorPoolCreateInfo* 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);
+    }
+}
+
+DescriptorSetAllocateInfo::DescriptorSetAllocateInfo(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];
+        }
+    }
+}
+
+DescriptorSetAllocateInfo::DescriptorSetAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO),
+      pNext(nullptr),
+      descriptorPool(),
+      descriptorSetCount(),
+      pSetLayouts(nullptr) {}
+
+DescriptorSetAllocateInfo::DescriptorSetAllocateInfo(const DescriptorSetAllocateInfo& 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];
+        }
+    }
+}
+
+DescriptorSetAllocateInfo& DescriptorSetAllocateInfo::operator=(const DescriptorSetAllocateInfo& 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;
+}
+
+DescriptorSetAllocateInfo::~DescriptorSetAllocateInfo() {
+    if (pSetLayouts) delete[] pSetLayouts;
+    FreePnextChain(pNext);
+}
+
+void DescriptorSetAllocateInfo::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 DescriptorSetAllocateInfo::initialize(const DescriptorSetAllocateInfo* 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];
+        }
+    }
+}
+
+DescriptorSetLayoutBinding::DescriptorSetLayoutBinding(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];
+        }
+    }
+}
+
+DescriptorSetLayoutBinding::DescriptorSetLayoutBinding()
+    : binding(), descriptorType(), descriptorCount(), stageFlags(), pImmutableSamplers(nullptr) {}
+
+DescriptorSetLayoutBinding::DescriptorSetLayoutBinding(const DescriptorSetLayoutBinding& 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];
+        }
+    }
+}
+
+DescriptorSetLayoutBinding& DescriptorSetLayoutBinding::operator=(const DescriptorSetLayoutBinding& 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;
+}
+
+DescriptorSetLayoutBinding::~DescriptorSetLayoutBinding() {
+    if (pImmutableSamplers) delete[] pImmutableSamplers;
+}
+
+void DescriptorSetLayoutBinding::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 DescriptorSetLayoutBinding::initialize(const DescriptorSetLayoutBinding* 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];
+        }
+    }
+}
+
+DescriptorSetLayoutCreateInfo::DescriptorSetLayoutCreateInfo(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 DescriptorSetLayoutBinding[bindingCount];
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            pBindings[i].initialize(&in_struct->pBindings[i]);
+        }
+    }
+}
+
+DescriptorSetLayoutCreateInfo::DescriptorSetLayoutCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO), pNext(nullptr), flags(), bindingCount(), pBindings(nullptr) {}
+
+DescriptorSetLayoutCreateInfo::DescriptorSetLayoutCreateInfo(const DescriptorSetLayoutCreateInfo& 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 DescriptorSetLayoutBinding[bindingCount];
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            pBindings[i].initialize(&copy_src.pBindings[i]);
+        }
+    }
+}
+
+DescriptorSetLayoutCreateInfo& DescriptorSetLayoutCreateInfo::operator=(const DescriptorSetLayoutCreateInfo& 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 DescriptorSetLayoutBinding[bindingCount];
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            pBindings[i].initialize(&copy_src.pBindings[i]);
+        }
+    }
+
+    return *this;
+}
+
+DescriptorSetLayoutCreateInfo::~DescriptorSetLayoutCreateInfo() {
+    if (pBindings) delete[] pBindings;
+    FreePnextChain(pNext);
+}
+
+void DescriptorSetLayoutCreateInfo::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 DescriptorSetLayoutBinding[bindingCount];
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            pBindings[i].initialize(&in_struct->pBindings[i]);
+        }
+    }
+}
+
+void DescriptorSetLayoutCreateInfo::initialize(const DescriptorSetLayoutCreateInfo* 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 DescriptorSetLayoutBinding[bindingCount];
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            pBindings[i].initialize(&copy_src->pBindings[i]);
+        }
+    }
+}
+
+WriteDescriptorSet::WriteDescriptorSet(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;
+    }
+}
+
+WriteDescriptorSet::WriteDescriptorSet()
+    : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET),
+      pNext(nullptr),
+      dstSet(),
+      dstBinding(),
+      dstArrayElement(),
+      descriptorCount(),
+      descriptorType(),
+      pImageInfo(nullptr),
+      pBufferInfo(nullptr),
+      pTexelBufferView(nullptr) {}
+
+WriteDescriptorSet::WriteDescriptorSet(const WriteDescriptorSet& 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;
+    }
+}
+
+WriteDescriptorSet& WriteDescriptorSet::operator=(const WriteDescriptorSet& 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;
+}
+
+WriteDescriptorSet::~WriteDescriptorSet() {
+    if (pImageInfo) delete[] pImageInfo;
+    if (pBufferInfo) delete[] pBufferInfo;
+    if (pTexelBufferView) delete[] pTexelBufferView;
+    FreePnextChain(pNext);
+}
+
+void WriteDescriptorSet::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 WriteDescriptorSet::initialize(const WriteDescriptorSet* 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;
+    }
+}
+
+FramebufferCreateInfo::FramebufferCreateInfo(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];
+        }
+    }
+}
+
+FramebufferCreateInfo::FramebufferCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      renderPass(),
+      attachmentCount(),
+      pAttachments(nullptr),
+      width(),
+      height(),
+      layers() {}
+
+FramebufferCreateInfo::FramebufferCreateInfo(const FramebufferCreateInfo& 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];
+        }
+    }
+}
+
+FramebufferCreateInfo& FramebufferCreateInfo::operator=(const FramebufferCreateInfo& 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;
+}
+
+FramebufferCreateInfo::~FramebufferCreateInfo() {
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+}
+
+void FramebufferCreateInfo::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 FramebufferCreateInfo::initialize(const FramebufferCreateInfo* 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];
+        }
+    }
+}
+
+SubpassDescription::SubpassDescription(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);
+    }
+}
+
+SubpassDescription::SubpassDescription()
+    : flags(),
+      pipelineBindPoint(),
+      inputAttachmentCount(),
+      pInputAttachments(nullptr),
+      colorAttachmentCount(),
+      pColorAttachments(nullptr),
+      pResolveAttachments(nullptr),
+      pDepthStencilAttachment(nullptr),
+      preserveAttachmentCount(),
+      pPreserveAttachments(nullptr) {}
+
+SubpassDescription::SubpassDescription(const SubpassDescription& 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);
+    }
+}
+
+SubpassDescription& SubpassDescription::operator=(const SubpassDescription& 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;
+}
+
+SubpassDescription::~SubpassDescription() {
+    if (pInputAttachments) delete[] pInputAttachments;
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pResolveAttachments) delete[] pResolveAttachments;
+    if (pDepthStencilAttachment) delete pDepthStencilAttachment;
+    if (pPreserveAttachments) delete[] pPreserveAttachments;
+}
+
+void SubpassDescription::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 SubpassDescription::initialize(const SubpassDescription* 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);
+    }
+}
+
+RenderPassCreateInfo::RenderPassCreateInfo(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 SubpassDescription[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);
+    }
+}
+
+RenderPassCreateInfo::RenderPassCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      attachmentCount(),
+      pAttachments(nullptr),
+      subpassCount(),
+      pSubpasses(nullptr),
+      dependencyCount(),
+      pDependencies(nullptr) {}
+
+RenderPassCreateInfo::RenderPassCreateInfo(const RenderPassCreateInfo& 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 SubpassDescription[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);
+    }
+}
+
+RenderPassCreateInfo& RenderPassCreateInfo::operator=(const RenderPassCreateInfo& 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 SubpassDescription[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;
+}
+
+RenderPassCreateInfo::~RenderPassCreateInfo() {
+    if (pAttachments) delete[] pAttachments;
+    if (pSubpasses) delete[] pSubpasses;
+    if (pDependencies) delete[] pDependencies;
+    FreePnextChain(pNext);
+}
+
+void RenderPassCreateInfo::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 SubpassDescription[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 RenderPassCreateInfo::initialize(const RenderPassCreateInfo* 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 SubpassDescription[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);
+    }
+}
+
+CommandPoolCreateInfo::CommandPoolCreateInfo(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);
+    }
+}
+
+CommandPoolCreateInfo::CommandPoolCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO), pNext(nullptr), flags(), queueFamilyIndex() {}
+
+CommandPoolCreateInfo::CommandPoolCreateInfo(const CommandPoolCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CommandPoolCreateInfo& CommandPoolCreateInfo::operator=(const CommandPoolCreateInfo& 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;
+}
+
+CommandPoolCreateInfo::~CommandPoolCreateInfo() { FreePnextChain(pNext); }
+
+void CommandPoolCreateInfo::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 CommandPoolCreateInfo::initialize(const CommandPoolCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    queueFamilyIndex = copy_src->queueFamilyIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CommandBufferAllocateInfo::CommandBufferAllocateInfo(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);
+    }
+}
+
+CommandBufferAllocateInfo::CommandBufferAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO), pNext(nullptr), commandPool(), level(), commandBufferCount() {}
+
+CommandBufferAllocateInfo::CommandBufferAllocateInfo(const CommandBufferAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    commandPool = copy_src.commandPool;
+    level = copy_src.level;
+    commandBufferCount = copy_src.commandBufferCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CommandBufferAllocateInfo& CommandBufferAllocateInfo::operator=(const CommandBufferAllocateInfo& 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;
+}
+
+CommandBufferAllocateInfo::~CommandBufferAllocateInfo() { FreePnextChain(pNext); }
+
+void CommandBufferAllocateInfo::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 CommandBufferAllocateInfo::initialize(const CommandBufferAllocateInfo* 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);
+}
+
+CommandBufferInheritanceInfo::CommandBufferInheritanceInfo(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);
+    }
+}
+
+CommandBufferInheritanceInfo::CommandBufferInheritanceInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO),
+      pNext(nullptr),
+      renderPass(),
+      subpass(),
+      framebuffer(),
+      occlusionQueryEnable(),
+      queryFlags(),
+      pipelineStatistics() {}
+
+CommandBufferInheritanceInfo::CommandBufferInheritanceInfo(const CommandBufferInheritanceInfo& 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);
+}
+
+CommandBufferInheritanceInfo& CommandBufferInheritanceInfo::operator=(const CommandBufferInheritanceInfo& 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;
+}
+
+CommandBufferInheritanceInfo::~CommandBufferInheritanceInfo() { FreePnextChain(pNext); }
+
+void CommandBufferInheritanceInfo::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 CommandBufferInheritanceInfo::initialize(const CommandBufferInheritanceInfo* 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);
+}
+
+CommandBufferBeginInfo::CommandBufferBeginInfo(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 CommandBufferInheritanceInfo(in_struct->pInheritanceInfo);
+}
+
+CommandBufferBeginInfo::CommandBufferBeginInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO), pNext(nullptr), flags(), pInheritanceInfo(nullptr) {}
+
+CommandBufferBeginInfo::CommandBufferBeginInfo(const CommandBufferBeginInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pInheritanceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pInheritanceInfo) pInheritanceInfo = new CommandBufferInheritanceInfo(*copy_src.pInheritanceInfo);
+}
+
+CommandBufferBeginInfo& CommandBufferBeginInfo::operator=(const CommandBufferBeginInfo& 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 CommandBufferInheritanceInfo(*copy_src.pInheritanceInfo);
+
+    return *this;
+}
+
+CommandBufferBeginInfo::~CommandBufferBeginInfo() {
+    if (pInheritanceInfo) delete pInheritanceInfo;
+    FreePnextChain(pNext);
+}
+
+void CommandBufferBeginInfo::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 CommandBufferInheritanceInfo(in_struct->pInheritanceInfo);
+}
+
+void CommandBufferBeginInfo::initialize(const CommandBufferBeginInfo* 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 CommandBufferInheritanceInfo(*copy_src->pInheritanceInfo);
+}
+
+RenderPassBeginInfo::RenderPassBeginInfo(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);
+    }
+}
+
+RenderPassBeginInfo::RenderPassBeginInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO),
+      pNext(nullptr),
+      renderPass(),
+      framebuffer(),
+      renderArea(),
+      clearValueCount(),
+      pClearValues(nullptr) {}
+
+RenderPassBeginInfo::RenderPassBeginInfo(const RenderPassBeginInfo& 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);
+    }
+}
+
+RenderPassBeginInfo& RenderPassBeginInfo::operator=(const RenderPassBeginInfo& 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;
+}
+
+RenderPassBeginInfo::~RenderPassBeginInfo() {
+    if (pClearValues) delete[] pClearValues;
+    FreePnextChain(pNext);
+}
+
+void RenderPassBeginInfo::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 RenderPassBeginInfo::initialize(const RenderPassBeginInfo* 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);
+    }
+}
+
+PhysicalDeviceSubgroupProperties::PhysicalDeviceSubgroupProperties(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);
+    }
+}
+
+PhysicalDeviceSubgroupProperties::PhysicalDeviceSubgroupProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES),
+      pNext(nullptr),
+      subgroupSize(),
+      supportedStages(),
+      supportedOperations(),
+      quadOperationsInAllStages() {}
+
+PhysicalDeviceSubgroupProperties::PhysicalDeviceSubgroupProperties(const PhysicalDeviceSubgroupProperties& 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);
+}
+
+PhysicalDeviceSubgroupProperties& PhysicalDeviceSubgroupProperties::operator=(const PhysicalDeviceSubgroupProperties& 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;
+}
+
+PhysicalDeviceSubgroupProperties::~PhysicalDeviceSubgroupProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSubgroupProperties::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 PhysicalDeviceSubgroupProperties::initialize(const PhysicalDeviceSubgroupProperties* 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);
+}
+
+BindBufferMemoryInfo::BindBufferMemoryInfo(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);
+    }
+}
+
+BindBufferMemoryInfo::BindBufferMemoryInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO), pNext(nullptr), buffer(), memory(), memoryOffset() {}
+
+BindBufferMemoryInfo::BindBufferMemoryInfo(const BindBufferMemoryInfo& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BindBufferMemoryInfo& BindBufferMemoryInfo::operator=(const BindBufferMemoryInfo& 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;
+}
+
+BindBufferMemoryInfo::~BindBufferMemoryInfo() { FreePnextChain(pNext); }
+
+void BindBufferMemoryInfo::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 BindBufferMemoryInfo::initialize(const BindBufferMemoryInfo* 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);
+}
+
+BindImageMemoryInfo::BindImageMemoryInfo(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);
+    }
+}
+
+BindImageMemoryInfo::BindImageMemoryInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO), pNext(nullptr), image(), memory(), memoryOffset() {}
+
+BindImageMemoryInfo::BindImageMemoryInfo(const BindImageMemoryInfo& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BindImageMemoryInfo& BindImageMemoryInfo::operator=(const BindImageMemoryInfo& 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;
+}
+
+BindImageMemoryInfo::~BindImageMemoryInfo() { FreePnextChain(pNext); }
+
+void BindImageMemoryInfo::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 BindImageMemoryInfo::initialize(const BindImageMemoryInfo* 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);
+}
+
+PhysicalDevice16BitStorageFeatures::PhysicalDevice16BitStorageFeatures(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);
+    }
+}
+
+PhysicalDevice16BitStorageFeatures::PhysicalDevice16BitStorageFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES),
+      pNext(nullptr),
+      storageBuffer16BitAccess(),
+      uniformAndStorageBuffer16BitAccess(),
+      storagePushConstant16(),
+      storageInputOutput16() {}
+
+PhysicalDevice16BitStorageFeatures::PhysicalDevice16BitStorageFeatures(const PhysicalDevice16BitStorageFeatures& 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);
+}
+
+PhysicalDevice16BitStorageFeatures& PhysicalDevice16BitStorageFeatures::operator=(
+    const PhysicalDevice16BitStorageFeatures& 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;
+}
+
+PhysicalDevice16BitStorageFeatures::~PhysicalDevice16BitStorageFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDevice16BitStorageFeatures::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 PhysicalDevice16BitStorageFeatures::initialize(const PhysicalDevice16BitStorageFeatures* 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);
+}
+
+MemoryDedicatedRequirements::MemoryDedicatedRequirements(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);
+    }
+}
+
+MemoryDedicatedRequirements::MemoryDedicatedRequirements()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS),
+      pNext(nullptr),
+      prefersDedicatedAllocation(),
+      requiresDedicatedAllocation() {}
+
+MemoryDedicatedRequirements::MemoryDedicatedRequirements(const MemoryDedicatedRequirements& copy_src) {
+    sType = copy_src.sType;
+    prefersDedicatedAllocation = copy_src.prefersDedicatedAllocation;
+    requiresDedicatedAllocation = copy_src.requiresDedicatedAllocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryDedicatedRequirements& MemoryDedicatedRequirements::operator=(const MemoryDedicatedRequirements& 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;
+}
+
+MemoryDedicatedRequirements::~MemoryDedicatedRequirements() { FreePnextChain(pNext); }
+
+void MemoryDedicatedRequirements::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 MemoryDedicatedRequirements::initialize(const MemoryDedicatedRequirements* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    prefersDedicatedAllocation = copy_src->prefersDedicatedAllocation;
+    requiresDedicatedAllocation = copy_src->requiresDedicatedAllocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryDedicatedAllocateInfo::MemoryDedicatedAllocateInfo(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);
+    }
+}
+
+MemoryDedicatedAllocateInfo::MemoryDedicatedAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO), pNext(nullptr), image(), buffer() {}
+
+MemoryDedicatedAllocateInfo::MemoryDedicatedAllocateInfo(const MemoryDedicatedAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryDedicatedAllocateInfo& MemoryDedicatedAllocateInfo::operator=(const MemoryDedicatedAllocateInfo& 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;
+}
+
+MemoryDedicatedAllocateInfo::~MemoryDedicatedAllocateInfo() { FreePnextChain(pNext); }
+
+void MemoryDedicatedAllocateInfo::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 MemoryDedicatedAllocateInfo::initialize(const MemoryDedicatedAllocateInfo* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryAllocateFlagsInfo::MemoryAllocateFlagsInfo(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);
+    }
+}
+
+MemoryAllocateFlagsInfo::MemoryAllocateFlagsInfo()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO), pNext(nullptr), flags(), deviceMask() {}
+
+MemoryAllocateFlagsInfo::MemoryAllocateFlagsInfo(const MemoryAllocateFlagsInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    deviceMask = copy_src.deviceMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryAllocateFlagsInfo& MemoryAllocateFlagsInfo::operator=(const MemoryAllocateFlagsInfo& 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;
+}
+
+MemoryAllocateFlagsInfo::~MemoryAllocateFlagsInfo() { FreePnextChain(pNext); }
+
+void MemoryAllocateFlagsInfo::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 MemoryAllocateFlagsInfo::initialize(const MemoryAllocateFlagsInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    deviceMask = copy_src->deviceMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DeviceGroupRenderPassBeginInfo::DeviceGroupRenderPassBeginInfo(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);
+    }
+}
+
+DeviceGroupRenderPassBeginInfo::DeviceGroupRenderPassBeginInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO),
+      pNext(nullptr),
+      deviceMask(),
+      deviceRenderAreaCount(),
+      pDeviceRenderAreas(nullptr) {}
+
+DeviceGroupRenderPassBeginInfo::DeviceGroupRenderPassBeginInfo(const DeviceGroupRenderPassBeginInfo& 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);
+    }
+}
+
+DeviceGroupRenderPassBeginInfo& DeviceGroupRenderPassBeginInfo::operator=(const DeviceGroupRenderPassBeginInfo& 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;
+}
+
+DeviceGroupRenderPassBeginInfo::~DeviceGroupRenderPassBeginInfo() {
+    if (pDeviceRenderAreas) delete[] pDeviceRenderAreas;
+    FreePnextChain(pNext);
+}
+
+void DeviceGroupRenderPassBeginInfo::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 DeviceGroupRenderPassBeginInfo::initialize(const DeviceGroupRenderPassBeginInfo* 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);
+    }
+}
+
+DeviceGroupCommandBufferBeginInfo::DeviceGroupCommandBufferBeginInfo(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);
+    }
+}
+
+DeviceGroupCommandBufferBeginInfo::DeviceGroupCommandBufferBeginInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO), pNext(nullptr), deviceMask() {}
+
+DeviceGroupCommandBufferBeginInfo::DeviceGroupCommandBufferBeginInfo(const DeviceGroupCommandBufferBeginInfo& copy_src) {
+    sType = copy_src.sType;
+    deviceMask = copy_src.deviceMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceGroupCommandBufferBeginInfo& DeviceGroupCommandBufferBeginInfo::operator=(const DeviceGroupCommandBufferBeginInfo& 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;
+}
+
+DeviceGroupCommandBufferBeginInfo::~DeviceGroupCommandBufferBeginInfo() { FreePnextChain(pNext); }
+
+void DeviceGroupCommandBufferBeginInfo::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 DeviceGroupCommandBufferBeginInfo::initialize(const DeviceGroupCommandBufferBeginInfo* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceMask = copy_src->deviceMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DeviceGroupSubmitInfo::DeviceGroupSubmitInfo(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);
+    }
+}
+
+DeviceGroupSubmitInfo::DeviceGroupSubmitInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO),
+      pNext(nullptr),
+      waitSemaphoreCount(),
+      pWaitSemaphoreDeviceIndices(nullptr),
+      commandBufferCount(),
+      pCommandBufferDeviceMasks(nullptr),
+      signalSemaphoreCount(),
+      pSignalSemaphoreDeviceIndices(nullptr) {}
+
+DeviceGroupSubmitInfo::DeviceGroupSubmitInfo(const DeviceGroupSubmitInfo& 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);
+    }
+}
+
+DeviceGroupSubmitInfo& DeviceGroupSubmitInfo::operator=(const DeviceGroupSubmitInfo& 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;
+}
+
+DeviceGroupSubmitInfo::~DeviceGroupSubmitInfo() {
+    if (pWaitSemaphoreDeviceIndices) delete[] pWaitSemaphoreDeviceIndices;
+    if (pCommandBufferDeviceMasks) delete[] pCommandBufferDeviceMasks;
+    if (pSignalSemaphoreDeviceIndices) delete[] pSignalSemaphoreDeviceIndices;
+    FreePnextChain(pNext);
+}
+
+void DeviceGroupSubmitInfo::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 DeviceGroupSubmitInfo::initialize(const DeviceGroupSubmitInfo* 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);
+    }
+}
+
+DeviceGroupBindSparseInfo::DeviceGroupBindSparseInfo(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);
+    }
+}
+
+DeviceGroupBindSparseInfo::DeviceGroupBindSparseInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO), pNext(nullptr), resourceDeviceIndex(), memoryDeviceIndex() {}
+
+DeviceGroupBindSparseInfo::DeviceGroupBindSparseInfo(const DeviceGroupBindSparseInfo& copy_src) {
+    sType = copy_src.sType;
+    resourceDeviceIndex = copy_src.resourceDeviceIndex;
+    memoryDeviceIndex = copy_src.memoryDeviceIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceGroupBindSparseInfo& DeviceGroupBindSparseInfo::operator=(const DeviceGroupBindSparseInfo& 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;
+}
+
+DeviceGroupBindSparseInfo::~DeviceGroupBindSparseInfo() { FreePnextChain(pNext); }
+
+void DeviceGroupBindSparseInfo::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 DeviceGroupBindSparseInfo::initialize(const DeviceGroupBindSparseInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    resourceDeviceIndex = copy_src->resourceDeviceIndex;
+    memoryDeviceIndex = copy_src->memoryDeviceIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BindBufferMemoryDeviceGroupInfo::BindBufferMemoryDeviceGroupInfo(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);
+    }
+}
+
+BindBufferMemoryDeviceGroupInfo::BindBufferMemoryDeviceGroupInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO), pNext(nullptr), deviceIndexCount(), pDeviceIndices(nullptr) {}
+
+BindBufferMemoryDeviceGroupInfo::BindBufferMemoryDeviceGroupInfo(const BindBufferMemoryDeviceGroupInfo& 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);
+    }
+}
+
+BindBufferMemoryDeviceGroupInfo& BindBufferMemoryDeviceGroupInfo::operator=(const BindBufferMemoryDeviceGroupInfo& 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;
+}
+
+BindBufferMemoryDeviceGroupInfo::~BindBufferMemoryDeviceGroupInfo() {
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    FreePnextChain(pNext);
+}
+
+void BindBufferMemoryDeviceGroupInfo::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 BindBufferMemoryDeviceGroupInfo::initialize(const BindBufferMemoryDeviceGroupInfo* 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);
+    }
+}
+
+BindImageMemoryDeviceGroupInfo::BindImageMemoryDeviceGroupInfo(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);
+    }
+}
+
+BindImageMemoryDeviceGroupInfo::BindImageMemoryDeviceGroupInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO),
+      pNext(nullptr),
+      deviceIndexCount(),
+      pDeviceIndices(nullptr),
+      splitInstanceBindRegionCount(),
+      pSplitInstanceBindRegions(nullptr) {}
+
+BindImageMemoryDeviceGroupInfo::BindImageMemoryDeviceGroupInfo(const BindImageMemoryDeviceGroupInfo& 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);
+    }
+}
+
+BindImageMemoryDeviceGroupInfo& BindImageMemoryDeviceGroupInfo::operator=(const BindImageMemoryDeviceGroupInfo& 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;
+}
+
+BindImageMemoryDeviceGroupInfo::~BindImageMemoryDeviceGroupInfo() {
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    if (pSplitInstanceBindRegions) delete[] pSplitInstanceBindRegions;
+    FreePnextChain(pNext);
+}
+
+void BindImageMemoryDeviceGroupInfo::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 BindImageMemoryDeviceGroupInfo::initialize(const BindImageMemoryDeviceGroupInfo* 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);
+    }
+}
+
+PhysicalDeviceGroupProperties::PhysicalDeviceGroupProperties(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];
+    }
+}
+
+PhysicalDeviceGroupProperties::PhysicalDeviceGroupProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES), pNext(nullptr), physicalDeviceCount(), subsetAllocation() {}
+
+PhysicalDeviceGroupProperties::PhysicalDeviceGroupProperties(const PhysicalDeviceGroupProperties& 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];
+    }
+}
+
+PhysicalDeviceGroupProperties& PhysicalDeviceGroupProperties::operator=(const PhysicalDeviceGroupProperties& 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;
+}
+
+PhysicalDeviceGroupProperties::~PhysicalDeviceGroupProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceGroupProperties::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 PhysicalDeviceGroupProperties::initialize(const PhysicalDeviceGroupProperties* 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];
+    }
+}
+
+DeviceGroupDeviceCreateInfo::DeviceGroupDeviceCreateInfo(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);
+    }
+}
+
+DeviceGroupDeviceCreateInfo::DeviceGroupDeviceCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO), pNext(nullptr), physicalDeviceCount(), pPhysicalDevices(nullptr) {}
+
+DeviceGroupDeviceCreateInfo::DeviceGroupDeviceCreateInfo(const DeviceGroupDeviceCreateInfo& 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);
+    }
+}
+
+DeviceGroupDeviceCreateInfo& DeviceGroupDeviceCreateInfo::operator=(const DeviceGroupDeviceCreateInfo& 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;
+}
+
+DeviceGroupDeviceCreateInfo::~DeviceGroupDeviceCreateInfo() {
+    if (pPhysicalDevices) delete[] pPhysicalDevices;
+    FreePnextChain(pNext);
+}
+
+void DeviceGroupDeviceCreateInfo::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 DeviceGroupDeviceCreateInfo::initialize(const DeviceGroupDeviceCreateInfo* 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);
+    }
+}
+
+BufferMemoryRequirementsInfo2::BufferMemoryRequirementsInfo2(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);
+    }
+}
+
+BufferMemoryRequirementsInfo2::BufferMemoryRequirementsInfo2()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2), pNext(nullptr), buffer() {}
+
+BufferMemoryRequirementsInfo2::BufferMemoryRequirementsInfo2(const BufferMemoryRequirementsInfo2& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BufferMemoryRequirementsInfo2& BufferMemoryRequirementsInfo2::operator=(const BufferMemoryRequirementsInfo2& 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;
+}
+
+BufferMemoryRequirementsInfo2::~BufferMemoryRequirementsInfo2() { FreePnextChain(pNext); }
+
+void BufferMemoryRequirementsInfo2::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 BufferMemoryRequirementsInfo2::initialize(const BufferMemoryRequirementsInfo2* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImageMemoryRequirementsInfo2::ImageMemoryRequirementsInfo2(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);
+    }
+}
+
+ImageMemoryRequirementsInfo2::ImageMemoryRequirementsInfo2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2), pNext(nullptr), image() {}
+
+ImageMemoryRequirementsInfo2::ImageMemoryRequirementsInfo2(const ImageMemoryRequirementsInfo2& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageMemoryRequirementsInfo2& ImageMemoryRequirementsInfo2::operator=(const ImageMemoryRequirementsInfo2& 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;
+}
+
+ImageMemoryRequirementsInfo2::~ImageMemoryRequirementsInfo2() { FreePnextChain(pNext); }
+
+void ImageMemoryRequirementsInfo2::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 ImageMemoryRequirementsInfo2::initialize(const ImageMemoryRequirementsInfo2* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImageSparseMemoryRequirementsInfo2::ImageSparseMemoryRequirementsInfo2(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);
+    }
+}
+
+ImageSparseMemoryRequirementsInfo2::ImageSparseMemoryRequirementsInfo2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2), pNext(nullptr), image() {}
+
+ImageSparseMemoryRequirementsInfo2::ImageSparseMemoryRequirementsInfo2(const ImageSparseMemoryRequirementsInfo2& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageSparseMemoryRequirementsInfo2& ImageSparseMemoryRequirementsInfo2::operator=(
+    const ImageSparseMemoryRequirementsInfo2& 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;
+}
+
+ImageSparseMemoryRequirementsInfo2::~ImageSparseMemoryRequirementsInfo2() { FreePnextChain(pNext); }
+
+void ImageSparseMemoryRequirementsInfo2::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 ImageSparseMemoryRequirementsInfo2::initialize(const ImageSparseMemoryRequirementsInfo2* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryRequirements2::MemoryRequirements2(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);
+    }
+}
+
+MemoryRequirements2::MemoryRequirements2() : sType(VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2), pNext(nullptr), memoryRequirements() {}
+
+MemoryRequirements2::MemoryRequirements2(const MemoryRequirements2& copy_src) {
+    sType = copy_src.sType;
+    memoryRequirements = copy_src.memoryRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryRequirements2& MemoryRequirements2::operator=(const MemoryRequirements2& 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;
+}
+
+MemoryRequirements2::~MemoryRequirements2() { FreePnextChain(pNext); }
+
+void MemoryRequirements2::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 MemoryRequirements2::initialize(const MemoryRequirements2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryRequirements = copy_src->memoryRequirements;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SparseImageMemoryRequirements2::SparseImageMemoryRequirements2(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);
+    }
+}
+
+SparseImageMemoryRequirements2::SparseImageMemoryRequirements2()
+    : sType(VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2), pNext(nullptr), memoryRequirements() {}
+
+SparseImageMemoryRequirements2::SparseImageMemoryRequirements2(const SparseImageMemoryRequirements2& copy_src) {
+    sType = copy_src.sType;
+    memoryRequirements = copy_src.memoryRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SparseImageMemoryRequirements2& SparseImageMemoryRequirements2::operator=(const SparseImageMemoryRequirements2& 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;
+}
+
+SparseImageMemoryRequirements2::~SparseImageMemoryRequirements2() { FreePnextChain(pNext); }
+
+void SparseImageMemoryRequirements2::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 SparseImageMemoryRequirements2::initialize(const SparseImageMemoryRequirements2* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryRequirements = copy_src->memoryRequirements;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceFeatures2::PhysicalDeviceFeatures2(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);
+    }
+}
+
+PhysicalDeviceFeatures2::PhysicalDeviceFeatures2()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2), pNext(nullptr), features() {}
+
+PhysicalDeviceFeatures2::PhysicalDeviceFeatures2(const PhysicalDeviceFeatures2& copy_src) {
+    sType = copy_src.sType;
+    features = copy_src.features;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFeatures2& PhysicalDeviceFeatures2::operator=(const PhysicalDeviceFeatures2& 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;
+}
+
+PhysicalDeviceFeatures2::~PhysicalDeviceFeatures2() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFeatures2::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 PhysicalDeviceFeatures2::initialize(const PhysicalDeviceFeatures2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    features = copy_src->features;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceProperties2::PhysicalDeviceProperties2(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);
+    }
+}
+
+PhysicalDeviceProperties2::PhysicalDeviceProperties2()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2), pNext(nullptr), properties() {}
+
+PhysicalDeviceProperties2::PhysicalDeviceProperties2(const PhysicalDeviceProperties2& copy_src) {
+    sType = copy_src.sType;
+    properties = copy_src.properties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceProperties2& PhysicalDeviceProperties2::operator=(const PhysicalDeviceProperties2& 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;
+}
+
+PhysicalDeviceProperties2::~PhysicalDeviceProperties2() { FreePnextChain(pNext); }
+
+void PhysicalDeviceProperties2::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 PhysicalDeviceProperties2::initialize(const PhysicalDeviceProperties2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    properties = copy_src->properties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+FormatProperties2::FormatProperties2(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);
+    }
+}
+
+FormatProperties2::FormatProperties2() : sType(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2), pNext(nullptr), formatProperties() {}
+
+FormatProperties2::FormatProperties2(const FormatProperties2& copy_src) {
+    sType = copy_src.sType;
+    formatProperties = copy_src.formatProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+FormatProperties2& FormatProperties2::operator=(const FormatProperties2& 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;
+}
+
+FormatProperties2::~FormatProperties2() { FreePnextChain(pNext); }
+
+void FormatProperties2::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 FormatProperties2::initialize(const FormatProperties2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    formatProperties = copy_src->formatProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImageFormatProperties2::ImageFormatProperties2(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);
+    }
+}
+
+ImageFormatProperties2::ImageFormatProperties2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2), pNext(nullptr), imageFormatProperties() {}
+
+ImageFormatProperties2::ImageFormatProperties2(const ImageFormatProperties2& copy_src) {
+    sType = copy_src.sType;
+    imageFormatProperties = copy_src.imageFormatProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageFormatProperties2& ImageFormatProperties2::operator=(const ImageFormatProperties2& 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;
+}
+
+ImageFormatProperties2::~ImageFormatProperties2() { FreePnextChain(pNext); }
+
+void ImageFormatProperties2::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 ImageFormatProperties2::initialize(const ImageFormatProperties2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageFormatProperties = copy_src->imageFormatProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceImageFormatInfo2::PhysicalDeviceImageFormatInfo2(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);
+    }
+}
+
+PhysicalDeviceImageFormatInfo2::PhysicalDeviceImageFormatInfo2()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2), pNext(nullptr), format(), type(), tiling(), usage(), flags() {}
+
+PhysicalDeviceImageFormatInfo2::PhysicalDeviceImageFormatInfo2(const PhysicalDeviceImageFormatInfo2& 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);
+}
+
+PhysicalDeviceImageFormatInfo2& PhysicalDeviceImageFormatInfo2::operator=(const PhysicalDeviceImageFormatInfo2& 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;
+}
+
+PhysicalDeviceImageFormatInfo2::~PhysicalDeviceImageFormatInfo2() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImageFormatInfo2::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 PhysicalDeviceImageFormatInfo2::initialize(const PhysicalDeviceImageFormatInfo2* 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);
+}
+
+QueueFamilyProperties2::QueueFamilyProperties2(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);
+    }
+}
+
+QueueFamilyProperties2::QueueFamilyProperties2()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2), pNext(nullptr), queueFamilyProperties() {}
+
+QueueFamilyProperties2::QueueFamilyProperties2(const QueueFamilyProperties2& copy_src) {
+    sType = copy_src.sType;
+    queueFamilyProperties = copy_src.queueFamilyProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+QueueFamilyProperties2& QueueFamilyProperties2::operator=(const QueueFamilyProperties2& 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;
+}
+
+QueueFamilyProperties2::~QueueFamilyProperties2() { FreePnextChain(pNext); }
+
+void QueueFamilyProperties2::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 QueueFamilyProperties2::initialize(const QueueFamilyProperties2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queueFamilyProperties = copy_src->queueFamilyProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMemoryProperties2::PhysicalDeviceMemoryProperties2(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);
+    }
+}
+
+PhysicalDeviceMemoryProperties2::PhysicalDeviceMemoryProperties2()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2), pNext(nullptr), memoryProperties() {}
+
+PhysicalDeviceMemoryProperties2::PhysicalDeviceMemoryProperties2(const PhysicalDeviceMemoryProperties2& copy_src) {
+    sType = copy_src.sType;
+    memoryProperties = copy_src.memoryProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMemoryProperties2& PhysicalDeviceMemoryProperties2::operator=(const PhysicalDeviceMemoryProperties2& 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;
+}
+
+PhysicalDeviceMemoryProperties2::~PhysicalDeviceMemoryProperties2() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMemoryProperties2::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 PhysicalDeviceMemoryProperties2::initialize(const PhysicalDeviceMemoryProperties2* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryProperties = copy_src->memoryProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SparseImageFormatProperties2::SparseImageFormatProperties2(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);
+    }
+}
+
+SparseImageFormatProperties2::SparseImageFormatProperties2()
+    : sType(VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2), pNext(nullptr), properties() {}
+
+SparseImageFormatProperties2::SparseImageFormatProperties2(const SparseImageFormatProperties2& copy_src) {
+    sType = copy_src.sType;
+    properties = copy_src.properties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SparseImageFormatProperties2& SparseImageFormatProperties2::operator=(const SparseImageFormatProperties2& 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;
+}
+
+SparseImageFormatProperties2::~SparseImageFormatProperties2() { FreePnextChain(pNext); }
+
+void SparseImageFormatProperties2::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 SparseImageFormatProperties2::initialize(const SparseImageFormatProperties2* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    properties = copy_src->properties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceSparseImageFormatInfo2::PhysicalDeviceSparseImageFormatInfo2(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);
+    }
+}
+
+PhysicalDeviceSparseImageFormatInfo2::PhysicalDeviceSparseImageFormatInfo2()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2),
+      pNext(nullptr),
+      format(),
+      type(),
+      samples(),
+      usage(),
+      tiling() {}
+
+PhysicalDeviceSparseImageFormatInfo2::PhysicalDeviceSparseImageFormatInfo2(const PhysicalDeviceSparseImageFormatInfo2& 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);
+}
+
+PhysicalDeviceSparseImageFormatInfo2& PhysicalDeviceSparseImageFormatInfo2::operator=(
+    const PhysicalDeviceSparseImageFormatInfo2& 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;
+}
+
+PhysicalDeviceSparseImageFormatInfo2::~PhysicalDeviceSparseImageFormatInfo2() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSparseImageFormatInfo2::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 PhysicalDeviceSparseImageFormatInfo2::initialize(const PhysicalDeviceSparseImageFormatInfo2* 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);
+}
+
+PhysicalDevicePointClippingProperties::PhysicalDevicePointClippingProperties(
+    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);
+    }
+}
+
+PhysicalDevicePointClippingProperties::PhysicalDevicePointClippingProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES), pNext(nullptr), pointClippingBehavior() {}
+
+PhysicalDevicePointClippingProperties::PhysicalDevicePointClippingProperties(
+    const PhysicalDevicePointClippingProperties& copy_src) {
+    sType = copy_src.sType;
+    pointClippingBehavior = copy_src.pointClippingBehavior;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePointClippingProperties& PhysicalDevicePointClippingProperties::operator=(
+    const PhysicalDevicePointClippingProperties& 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;
+}
+
+PhysicalDevicePointClippingProperties::~PhysicalDevicePointClippingProperties() { FreePnextChain(pNext); }
+
+void PhysicalDevicePointClippingProperties::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 PhysicalDevicePointClippingProperties::initialize(const PhysicalDevicePointClippingProperties* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pointClippingBehavior = copy_src->pointClippingBehavior;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+RenderPassInputAttachmentAspectCreateInfo::RenderPassInputAttachmentAspectCreateInfo(
+    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);
+    }
+}
+
+RenderPassInputAttachmentAspectCreateInfo::RenderPassInputAttachmentAspectCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO),
+      pNext(nullptr),
+      aspectReferenceCount(),
+      pAspectReferences(nullptr) {}
+
+RenderPassInputAttachmentAspectCreateInfo::RenderPassInputAttachmentAspectCreateInfo(
+    const RenderPassInputAttachmentAspectCreateInfo& 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);
+    }
+}
+
+RenderPassInputAttachmentAspectCreateInfo& RenderPassInputAttachmentAspectCreateInfo::operator=(
+    const RenderPassInputAttachmentAspectCreateInfo& 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;
+}
+
+RenderPassInputAttachmentAspectCreateInfo::~RenderPassInputAttachmentAspectCreateInfo() {
+    if (pAspectReferences) delete[] pAspectReferences;
+    FreePnextChain(pNext);
+}
+
+void RenderPassInputAttachmentAspectCreateInfo::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 RenderPassInputAttachmentAspectCreateInfo::initialize(const RenderPassInputAttachmentAspectCreateInfo* 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);
+    }
+}
+
+ImageViewUsageCreateInfo::ImageViewUsageCreateInfo(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);
+    }
+}
+
+ImageViewUsageCreateInfo::ImageViewUsageCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO), pNext(nullptr), usage() {}
+
+ImageViewUsageCreateInfo::ImageViewUsageCreateInfo(const ImageViewUsageCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageViewUsageCreateInfo& ImageViewUsageCreateInfo::operator=(const ImageViewUsageCreateInfo& 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;
+}
+
+ImageViewUsageCreateInfo::~ImageViewUsageCreateInfo() { FreePnextChain(pNext); }
+
+void ImageViewUsageCreateInfo::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 ImageViewUsageCreateInfo::initialize(const ImageViewUsageCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    usage = copy_src->usage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineTessellationDomainOriginStateCreateInfo::PipelineTessellationDomainOriginStateCreateInfo(
+    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);
+    }
+}
+
+PipelineTessellationDomainOriginStateCreateInfo::PipelineTessellationDomainOriginStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO), pNext(nullptr), domainOrigin() {}
+
+PipelineTessellationDomainOriginStateCreateInfo::PipelineTessellationDomainOriginStateCreateInfo(
+    const PipelineTessellationDomainOriginStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    domainOrigin = copy_src.domainOrigin;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineTessellationDomainOriginStateCreateInfo& PipelineTessellationDomainOriginStateCreateInfo::operator=(
+    const PipelineTessellationDomainOriginStateCreateInfo& 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;
+}
+
+PipelineTessellationDomainOriginStateCreateInfo::~PipelineTessellationDomainOriginStateCreateInfo() { FreePnextChain(pNext); }
+
+void PipelineTessellationDomainOriginStateCreateInfo::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 PipelineTessellationDomainOriginStateCreateInfo::initialize(const PipelineTessellationDomainOriginStateCreateInfo* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    domainOrigin = copy_src->domainOrigin;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+RenderPassMultiviewCreateInfo::RenderPassMultiviewCreateInfo(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);
+    }
+}
+
+RenderPassMultiviewCreateInfo::RenderPassMultiviewCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO),
+      pNext(nullptr),
+      subpassCount(),
+      pViewMasks(nullptr),
+      dependencyCount(),
+      pViewOffsets(nullptr),
+      correlationMaskCount(),
+      pCorrelationMasks(nullptr) {}
+
+RenderPassMultiviewCreateInfo::RenderPassMultiviewCreateInfo(const RenderPassMultiviewCreateInfo& 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);
+    }
+}
+
+RenderPassMultiviewCreateInfo& RenderPassMultiviewCreateInfo::operator=(const RenderPassMultiviewCreateInfo& 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;
+}
+
+RenderPassMultiviewCreateInfo::~RenderPassMultiviewCreateInfo() {
+    if (pViewMasks) delete[] pViewMasks;
+    if (pViewOffsets) delete[] pViewOffsets;
+    if (pCorrelationMasks) delete[] pCorrelationMasks;
+    FreePnextChain(pNext);
+}
+
+void RenderPassMultiviewCreateInfo::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 RenderPassMultiviewCreateInfo::initialize(const RenderPassMultiviewCreateInfo* 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);
+    }
+}
+
+PhysicalDeviceMultiviewFeatures::PhysicalDeviceMultiviewFeatures(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);
+    }
+}
+
+PhysicalDeviceMultiviewFeatures::PhysicalDeviceMultiviewFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES),
+      pNext(nullptr),
+      multiview(),
+      multiviewGeometryShader(),
+      multiviewTessellationShader() {}
+
+PhysicalDeviceMultiviewFeatures::PhysicalDeviceMultiviewFeatures(const PhysicalDeviceMultiviewFeatures& copy_src) {
+    sType = copy_src.sType;
+    multiview = copy_src.multiview;
+    multiviewGeometryShader = copy_src.multiviewGeometryShader;
+    multiviewTessellationShader = copy_src.multiviewTessellationShader;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMultiviewFeatures& PhysicalDeviceMultiviewFeatures::operator=(const PhysicalDeviceMultiviewFeatures& 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;
+}
+
+PhysicalDeviceMultiviewFeatures::~PhysicalDeviceMultiviewFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMultiviewFeatures::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 PhysicalDeviceMultiviewFeatures::initialize(const PhysicalDeviceMultiviewFeatures* 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);
+}
+
+PhysicalDeviceMultiviewProperties::PhysicalDeviceMultiviewProperties(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);
+    }
+}
+
+PhysicalDeviceMultiviewProperties::PhysicalDeviceMultiviewProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES),
+      pNext(nullptr),
+      maxMultiviewViewCount(),
+      maxMultiviewInstanceIndex() {}
+
+PhysicalDeviceMultiviewProperties::PhysicalDeviceMultiviewProperties(const PhysicalDeviceMultiviewProperties& copy_src) {
+    sType = copy_src.sType;
+    maxMultiviewViewCount = copy_src.maxMultiviewViewCount;
+    maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMultiviewProperties& PhysicalDeviceMultiviewProperties::operator=(const PhysicalDeviceMultiviewProperties& 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;
+}
+
+PhysicalDeviceMultiviewProperties::~PhysicalDeviceMultiviewProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMultiviewProperties::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 PhysicalDeviceMultiviewProperties::initialize(const PhysicalDeviceMultiviewProperties* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxMultiviewViewCount = copy_src->maxMultiviewViewCount;
+    maxMultiviewInstanceIndex = copy_src->maxMultiviewInstanceIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceVariablePointersFeatures::PhysicalDeviceVariablePointersFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceVariablePointersFeatures::PhysicalDeviceVariablePointersFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES),
+      pNext(nullptr),
+      variablePointersStorageBuffer(),
+      variablePointers() {}
+
+PhysicalDeviceVariablePointersFeatures::PhysicalDeviceVariablePointersFeatures(
+    const PhysicalDeviceVariablePointersFeatures& copy_src) {
+    sType = copy_src.sType;
+    variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer;
+    variablePointers = copy_src.variablePointers;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceVariablePointersFeatures& PhysicalDeviceVariablePointersFeatures::operator=(
+    const PhysicalDeviceVariablePointersFeatures& 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;
+}
+
+PhysicalDeviceVariablePointersFeatures::~PhysicalDeviceVariablePointersFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVariablePointersFeatures::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 PhysicalDeviceVariablePointersFeatures::initialize(const PhysicalDeviceVariablePointersFeatures* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    variablePointersStorageBuffer = copy_src->variablePointersStorageBuffer;
+    variablePointers = copy_src->variablePointers;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceProtectedMemoryFeatures::PhysicalDeviceProtectedMemoryFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceProtectedMemoryFeatures::PhysicalDeviceProtectedMemoryFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES), pNext(nullptr), protectedMemory() {}
+
+PhysicalDeviceProtectedMemoryFeatures::PhysicalDeviceProtectedMemoryFeatures(
+    const PhysicalDeviceProtectedMemoryFeatures& copy_src) {
+    sType = copy_src.sType;
+    protectedMemory = copy_src.protectedMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceProtectedMemoryFeatures& PhysicalDeviceProtectedMemoryFeatures::operator=(
+    const PhysicalDeviceProtectedMemoryFeatures& 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;
+}
+
+PhysicalDeviceProtectedMemoryFeatures::~PhysicalDeviceProtectedMemoryFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceProtectedMemoryFeatures::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 PhysicalDeviceProtectedMemoryFeatures::initialize(const PhysicalDeviceProtectedMemoryFeatures* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    protectedMemory = copy_src->protectedMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceProtectedMemoryProperties::PhysicalDeviceProtectedMemoryProperties(
+    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);
+    }
+}
+
+PhysicalDeviceProtectedMemoryProperties::PhysicalDeviceProtectedMemoryProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES), pNext(nullptr), protectedNoFault() {}
+
+PhysicalDeviceProtectedMemoryProperties::PhysicalDeviceProtectedMemoryProperties(
+    const PhysicalDeviceProtectedMemoryProperties& copy_src) {
+    sType = copy_src.sType;
+    protectedNoFault = copy_src.protectedNoFault;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceProtectedMemoryProperties& PhysicalDeviceProtectedMemoryProperties::operator=(
+    const PhysicalDeviceProtectedMemoryProperties& 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;
+}
+
+PhysicalDeviceProtectedMemoryProperties::~PhysicalDeviceProtectedMemoryProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceProtectedMemoryProperties::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 PhysicalDeviceProtectedMemoryProperties::initialize(const PhysicalDeviceProtectedMemoryProperties* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    protectedNoFault = copy_src->protectedNoFault;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DeviceQueueInfo2::DeviceQueueInfo2(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);
+    }
+}
+
+DeviceQueueInfo2::DeviceQueueInfo2()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2), pNext(nullptr), flags(), queueFamilyIndex(), queueIndex() {}
+
+DeviceQueueInfo2::DeviceQueueInfo2(const DeviceQueueInfo2& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    queueIndex = copy_src.queueIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceQueueInfo2& DeviceQueueInfo2::operator=(const DeviceQueueInfo2& 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;
+}
+
+DeviceQueueInfo2::~DeviceQueueInfo2() { FreePnextChain(pNext); }
+
+void DeviceQueueInfo2::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 DeviceQueueInfo2::initialize(const DeviceQueueInfo2* 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);
+}
+
+ProtectedSubmitInfo::ProtectedSubmitInfo(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);
+    }
+}
+
+ProtectedSubmitInfo::ProtectedSubmitInfo() : sType(VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO), pNext(nullptr), protectedSubmit() {}
+
+ProtectedSubmitInfo::ProtectedSubmitInfo(const ProtectedSubmitInfo& copy_src) {
+    sType = copy_src.sType;
+    protectedSubmit = copy_src.protectedSubmit;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ProtectedSubmitInfo& ProtectedSubmitInfo::operator=(const ProtectedSubmitInfo& 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;
+}
+
+ProtectedSubmitInfo::~ProtectedSubmitInfo() { FreePnextChain(pNext); }
+
+void ProtectedSubmitInfo::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 ProtectedSubmitInfo::initialize(const ProtectedSubmitInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    protectedSubmit = copy_src->protectedSubmit;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SamplerYcbcrConversionCreateInfo::SamplerYcbcrConversionCreateInfo(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);
+    }
+}
+
+SamplerYcbcrConversionCreateInfo::SamplerYcbcrConversionCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO),
+      pNext(nullptr),
+      format(),
+      ycbcrModel(),
+      ycbcrRange(),
+      components(),
+      xChromaOffset(),
+      yChromaOffset(),
+      chromaFilter(),
+      forceExplicitReconstruction() {}
+
+SamplerYcbcrConversionCreateInfo::SamplerYcbcrConversionCreateInfo(const SamplerYcbcrConversionCreateInfo& 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);
+}
+
+SamplerYcbcrConversionCreateInfo& SamplerYcbcrConversionCreateInfo::operator=(const SamplerYcbcrConversionCreateInfo& 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;
+}
+
+SamplerYcbcrConversionCreateInfo::~SamplerYcbcrConversionCreateInfo() { FreePnextChain(pNext); }
+
+void SamplerYcbcrConversionCreateInfo::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 SamplerYcbcrConversionCreateInfo::initialize(const SamplerYcbcrConversionCreateInfo* 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);
+}
+
+SamplerYcbcrConversionInfo::SamplerYcbcrConversionInfo(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);
+    }
+}
+
+SamplerYcbcrConversionInfo::SamplerYcbcrConversionInfo()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO), pNext(nullptr), conversion() {}
+
+SamplerYcbcrConversionInfo::SamplerYcbcrConversionInfo(const SamplerYcbcrConversionInfo& copy_src) {
+    sType = copy_src.sType;
+    conversion = copy_src.conversion;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SamplerYcbcrConversionInfo& SamplerYcbcrConversionInfo::operator=(const SamplerYcbcrConversionInfo& 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;
+}
+
+SamplerYcbcrConversionInfo::~SamplerYcbcrConversionInfo() { FreePnextChain(pNext); }
+
+void SamplerYcbcrConversionInfo::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 SamplerYcbcrConversionInfo::initialize(const SamplerYcbcrConversionInfo* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    conversion = copy_src->conversion;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BindImagePlaneMemoryInfo::BindImagePlaneMemoryInfo(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);
+    }
+}
+
+BindImagePlaneMemoryInfo::BindImagePlaneMemoryInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO), pNext(nullptr), planeAspect() {}
+
+BindImagePlaneMemoryInfo::BindImagePlaneMemoryInfo(const BindImagePlaneMemoryInfo& copy_src) {
+    sType = copy_src.sType;
+    planeAspect = copy_src.planeAspect;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BindImagePlaneMemoryInfo& BindImagePlaneMemoryInfo::operator=(const BindImagePlaneMemoryInfo& 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;
+}
+
+BindImagePlaneMemoryInfo::~BindImagePlaneMemoryInfo() { FreePnextChain(pNext); }
+
+void BindImagePlaneMemoryInfo::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 BindImagePlaneMemoryInfo::initialize(const BindImagePlaneMemoryInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    planeAspect = copy_src->planeAspect;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImagePlaneMemoryRequirementsInfo::ImagePlaneMemoryRequirementsInfo(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);
+    }
+}
+
+ImagePlaneMemoryRequirementsInfo::ImagePlaneMemoryRequirementsInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO), pNext(nullptr), planeAspect() {}
+
+ImagePlaneMemoryRequirementsInfo::ImagePlaneMemoryRequirementsInfo(const ImagePlaneMemoryRequirementsInfo& copy_src) {
+    sType = copy_src.sType;
+    planeAspect = copy_src.planeAspect;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImagePlaneMemoryRequirementsInfo& ImagePlaneMemoryRequirementsInfo::operator=(const ImagePlaneMemoryRequirementsInfo& 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;
+}
+
+ImagePlaneMemoryRequirementsInfo::~ImagePlaneMemoryRequirementsInfo() { FreePnextChain(pNext); }
+
+void ImagePlaneMemoryRequirementsInfo::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 ImagePlaneMemoryRequirementsInfo::initialize(const ImagePlaneMemoryRequirementsInfo* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    planeAspect = copy_src->planeAspect;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceSamplerYcbcrConversionFeatures::PhysicalDeviceSamplerYcbcrConversionFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceSamplerYcbcrConversionFeatures::PhysicalDeviceSamplerYcbcrConversionFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES), pNext(nullptr), samplerYcbcrConversion() {}
+
+PhysicalDeviceSamplerYcbcrConversionFeatures::PhysicalDeviceSamplerYcbcrConversionFeatures(
+    const PhysicalDeviceSamplerYcbcrConversionFeatures& copy_src) {
+    sType = copy_src.sType;
+    samplerYcbcrConversion = copy_src.samplerYcbcrConversion;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSamplerYcbcrConversionFeatures& PhysicalDeviceSamplerYcbcrConversionFeatures::operator=(
+    const PhysicalDeviceSamplerYcbcrConversionFeatures& 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;
+}
+
+PhysicalDeviceSamplerYcbcrConversionFeatures::~PhysicalDeviceSamplerYcbcrConversionFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSamplerYcbcrConversionFeatures::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 PhysicalDeviceSamplerYcbcrConversionFeatures::initialize(const PhysicalDeviceSamplerYcbcrConversionFeatures* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    samplerYcbcrConversion = copy_src->samplerYcbcrConversion;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SamplerYcbcrConversionImageFormatProperties::SamplerYcbcrConversionImageFormatProperties(
+    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);
+    }
+}
+
+SamplerYcbcrConversionImageFormatProperties::SamplerYcbcrConversionImageFormatProperties()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES),
+      pNext(nullptr),
+      combinedImageSamplerDescriptorCount() {}
+
+SamplerYcbcrConversionImageFormatProperties::SamplerYcbcrConversionImageFormatProperties(
+    const SamplerYcbcrConversionImageFormatProperties& copy_src) {
+    sType = copy_src.sType;
+    combinedImageSamplerDescriptorCount = copy_src.combinedImageSamplerDescriptorCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SamplerYcbcrConversionImageFormatProperties& SamplerYcbcrConversionImageFormatProperties::operator=(
+    const SamplerYcbcrConversionImageFormatProperties& 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;
+}
+
+SamplerYcbcrConversionImageFormatProperties::~SamplerYcbcrConversionImageFormatProperties() { FreePnextChain(pNext); }
+
+void SamplerYcbcrConversionImageFormatProperties::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 SamplerYcbcrConversionImageFormatProperties::initialize(const SamplerYcbcrConversionImageFormatProperties* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    combinedImageSamplerDescriptorCount = copy_src->combinedImageSamplerDescriptorCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DescriptorUpdateTemplateCreateInfo::DescriptorUpdateTemplateCreateInfo(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);
+    }
+}
+
+DescriptorUpdateTemplateCreateInfo::DescriptorUpdateTemplateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      descriptorUpdateEntryCount(),
+      pDescriptorUpdateEntries(nullptr),
+      templateType(),
+      descriptorSetLayout(),
+      pipelineBindPoint(),
+      pipelineLayout(),
+      set() {}
+
+DescriptorUpdateTemplateCreateInfo::DescriptorUpdateTemplateCreateInfo(const DescriptorUpdateTemplateCreateInfo& 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);
+    }
+}
+
+DescriptorUpdateTemplateCreateInfo& DescriptorUpdateTemplateCreateInfo::operator=(
+    const DescriptorUpdateTemplateCreateInfo& 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;
+}
+
+DescriptorUpdateTemplateCreateInfo::~DescriptorUpdateTemplateCreateInfo() {
+    if (pDescriptorUpdateEntries) delete[] pDescriptorUpdateEntries;
+    FreePnextChain(pNext);
+}
+
+void DescriptorUpdateTemplateCreateInfo::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 DescriptorUpdateTemplateCreateInfo::initialize(const DescriptorUpdateTemplateCreateInfo* 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);
+    }
+}
+
+PhysicalDeviceExternalImageFormatInfo::PhysicalDeviceExternalImageFormatInfo(
+    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);
+    }
+}
+
+PhysicalDeviceExternalImageFormatInfo::PhysicalDeviceExternalImageFormatInfo()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO), pNext(nullptr), handleType() {}
+
+PhysicalDeviceExternalImageFormatInfo::PhysicalDeviceExternalImageFormatInfo(
+    const PhysicalDeviceExternalImageFormatInfo& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExternalImageFormatInfo& PhysicalDeviceExternalImageFormatInfo::operator=(
+    const PhysicalDeviceExternalImageFormatInfo& 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;
+}
+
+PhysicalDeviceExternalImageFormatInfo::~PhysicalDeviceExternalImageFormatInfo() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExternalImageFormatInfo::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 PhysicalDeviceExternalImageFormatInfo::initialize(const PhysicalDeviceExternalImageFormatInfo* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExternalImageFormatProperties::ExternalImageFormatProperties(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);
+    }
+}
+
+ExternalImageFormatProperties::ExternalImageFormatProperties()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES), pNext(nullptr), externalMemoryProperties() {}
+
+ExternalImageFormatProperties::ExternalImageFormatProperties(const ExternalImageFormatProperties& copy_src) {
+    sType = copy_src.sType;
+    externalMemoryProperties = copy_src.externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExternalImageFormatProperties& ExternalImageFormatProperties::operator=(const ExternalImageFormatProperties& 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;
+}
+
+ExternalImageFormatProperties::~ExternalImageFormatProperties() { FreePnextChain(pNext); }
+
+void ExternalImageFormatProperties::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 ExternalImageFormatProperties::initialize(const ExternalImageFormatProperties* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalMemoryProperties = copy_src->externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceExternalBufferInfo::PhysicalDeviceExternalBufferInfo(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);
+    }
+}
+
+PhysicalDeviceExternalBufferInfo::PhysicalDeviceExternalBufferInfo()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO), pNext(nullptr), flags(), usage(), handleType() {}
+
+PhysicalDeviceExternalBufferInfo::PhysicalDeviceExternalBufferInfo(const PhysicalDeviceExternalBufferInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    usage = copy_src.usage;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExternalBufferInfo& PhysicalDeviceExternalBufferInfo::operator=(const PhysicalDeviceExternalBufferInfo& 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;
+}
+
+PhysicalDeviceExternalBufferInfo::~PhysicalDeviceExternalBufferInfo() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExternalBufferInfo::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 PhysicalDeviceExternalBufferInfo::initialize(const PhysicalDeviceExternalBufferInfo* 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);
+}
+
+ExternalBufferProperties::ExternalBufferProperties(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);
+    }
+}
+
+ExternalBufferProperties::ExternalBufferProperties()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES), pNext(nullptr), externalMemoryProperties() {}
+
+ExternalBufferProperties::ExternalBufferProperties(const ExternalBufferProperties& copy_src) {
+    sType = copy_src.sType;
+    externalMemoryProperties = copy_src.externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExternalBufferProperties& ExternalBufferProperties::operator=(const ExternalBufferProperties& 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;
+}
+
+ExternalBufferProperties::~ExternalBufferProperties() { FreePnextChain(pNext); }
+
+void ExternalBufferProperties::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 ExternalBufferProperties::initialize(const ExternalBufferProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalMemoryProperties = copy_src->externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceIDProperties::PhysicalDeviceIDProperties(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];
+    }
+}
+
+PhysicalDeviceIDProperties::PhysicalDeviceIDProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES), pNext(nullptr), deviceNodeMask(), deviceLUIDValid() {}
+
+PhysicalDeviceIDProperties::PhysicalDeviceIDProperties(const PhysicalDeviceIDProperties& 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];
+    }
+}
+
+PhysicalDeviceIDProperties& PhysicalDeviceIDProperties::operator=(const PhysicalDeviceIDProperties& 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;
+}
+
+PhysicalDeviceIDProperties::~PhysicalDeviceIDProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceIDProperties::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 PhysicalDeviceIDProperties::initialize(const PhysicalDeviceIDProperties* 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];
+    }
+}
+
+ExternalMemoryImageCreateInfo::ExternalMemoryImageCreateInfo(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);
+    }
+}
+
+ExternalMemoryImageCreateInfo::ExternalMemoryImageCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO), pNext(nullptr), handleTypes() {}
+
+ExternalMemoryImageCreateInfo::ExternalMemoryImageCreateInfo(const ExternalMemoryImageCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExternalMemoryImageCreateInfo& ExternalMemoryImageCreateInfo::operator=(const ExternalMemoryImageCreateInfo& 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;
+}
+
+ExternalMemoryImageCreateInfo::~ExternalMemoryImageCreateInfo() { FreePnextChain(pNext); }
+
+void ExternalMemoryImageCreateInfo::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 ExternalMemoryImageCreateInfo::initialize(const ExternalMemoryImageCreateInfo* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExternalMemoryBufferCreateInfo::ExternalMemoryBufferCreateInfo(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);
+    }
+}
+
+ExternalMemoryBufferCreateInfo::ExternalMemoryBufferCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO), pNext(nullptr), handleTypes() {}
+
+ExternalMemoryBufferCreateInfo::ExternalMemoryBufferCreateInfo(const ExternalMemoryBufferCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExternalMemoryBufferCreateInfo& ExternalMemoryBufferCreateInfo::operator=(const ExternalMemoryBufferCreateInfo& 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;
+}
+
+ExternalMemoryBufferCreateInfo::~ExternalMemoryBufferCreateInfo() { FreePnextChain(pNext); }
+
+void ExternalMemoryBufferCreateInfo::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 ExternalMemoryBufferCreateInfo::initialize(const ExternalMemoryBufferCreateInfo* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExportMemoryAllocateInfo::ExportMemoryAllocateInfo(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);
+    }
+}
+
+ExportMemoryAllocateInfo::ExportMemoryAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO), pNext(nullptr), handleTypes() {}
+
+ExportMemoryAllocateInfo::ExportMemoryAllocateInfo(const ExportMemoryAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExportMemoryAllocateInfo& ExportMemoryAllocateInfo::operator=(const ExportMemoryAllocateInfo& 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;
+}
+
+ExportMemoryAllocateInfo::~ExportMemoryAllocateInfo() { FreePnextChain(pNext); }
+
+void ExportMemoryAllocateInfo::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 ExportMemoryAllocateInfo::initialize(const ExportMemoryAllocateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceExternalFenceInfo::PhysicalDeviceExternalFenceInfo(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);
+    }
+}
+
+PhysicalDeviceExternalFenceInfo::PhysicalDeviceExternalFenceInfo()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO), pNext(nullptr), handleType() {}
+
+PhysicalDeviceExternalFenceInfo::PhysicalDeviceExternalFenceInfo(const PhysicalDeviceExternalFenceInfo& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExternalFenceInfo& PhysicalDeviceExternalFenceInfo::operator=(const PhysicalDeviceExternalFenceInfo& 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;
+}
+
+PhysicalDeviceExternalFenceInfo::~PhysicalDeviceExternalFenceInfo() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExternalFenceInfo::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 PhysicalDeviceExternalFenceInfo::initialize(const PhysicalDeviceExternalFenceInfo* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExternalFenceProperties::ExternalFenceProperties(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);
+    }
+}
+
+ExternalFenceProperties::ExternalFenceProperties()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES),
+      pNext(nullptr),
+      exportFromImportedHandleTypes(),
+      compatibleHandleTypes(),
+      externalFenceFeatures() {}
+
+ExternalFenceProperties::ExternalFenceProperties(const ExternalFenceProperties& copy_src) {
+    sType = copy_src.sType;
+    exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes;
+    compatibleHandleTypes = copy_src.compatibleHandleTypes;
+    externalFenceFeatures = copy_src.externalFenceFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExternalFenceProperties& ExternalFenceProperties::operator=(const ExternalFenceProperties& 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;
+}
+
+ExternalFenceProperties::~ExternalFenceProperties() { FreePnextChain(pNext); }
+
+void ExternalFenceProperties::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 ExternalFenceProperties::initialize(const ExternalFenceProperties* 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);
+}
+
+ExportFenceCreateInfo::ExportFenceCreateInfo(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);
+    }
+}
+
+ExportFenceCreateInfo::ExportFenceCreateInfo() : sType(VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO), pNext(nullptr), handleTypes() {}
+
+ExportFenceCreateInfo::ExportFenceCreateInfo(const ExportFenceCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExportFenceCreateInfo& ExportFenceCreateInfo::operator=(const ExportFenceCreateInfo& 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;
+}
+
+ExportFenceCreateInfo::~ExportFenceCreateInfo() { FreePnextChain(pNext); }
+
+void ExportFenceCreateInfo::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 ExportFenceCreateInfo::initialize(const ExportFenceCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExportSemaphoreCreateInfo::ExportSemaphoreCreateInfo(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);
+    }
+}
+
+ExportSemaphoreCreateInfo::ExportSemaphoreCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO), pNext(nullptr), handleTypes() {}
+
+ExportSemaphoreCreateInfo::ExportSemaphoreCreateInfo(const ExportSemaphoreCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExportSemaphoreCreateInfo& ExportSemaphoreCreateInfo::operator=(const ExportSemaphoreCreateInfo& 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;
+}
+
+ExportSemaphoreCreateInfo::~ExportSemaphoreCreateInfo() { FreePnextChain(pNext); }
+
+void ExportSemaphoreCreateInfo::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 ExportSemaphoreCreateInfo::initialize(const ExportSemaphoreCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceExternalSemaphoreInfo::PhysicalDeviceExternalSemaphoreInfo(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);
+    }
+}
+
+PhysicalDeviceExternalSemaphoreInfo::PhysicalDeviceExternalSemaphoreInfo()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO), pNext(nullptr), handleType() {}
+
+PhysicalDeviceExternalSemaphoreInfo::PhysicalDeviceExternalSemaphoreInfo(const PhysicalDeviceExternalSemaphoreInfo& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExternalSemaphoreInfo& PhysicalDeviceExternalSemaphoreInfo::operator=(
+    const PhysicalDeviceExternalSemaphoreInfo& 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;
+}
+
+PhysicalDeviceExternalSemaphoreInfo::~PhysicalDeviceExternalSemaphoreInfo() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExternalSemaphoreInfo::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 PhysicalDeviceExternalSemaphoreInfo::initialize(const PhysicalDeviceExternalSemaphoreInfo* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExternalSemaphoreProperties::ExternalSemaphoreProperties(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);
+    }
+}
+
+ExternalSemaphoreProperties::ExternalSemaphoreProperties()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES),
+      pNext(nullptr),
+      exportFromImportedHandleTypes(),
+      compatibleHandleTypes(),
+      externalSemaphoreFeatures() {}
+
+ExternalSemaphoreProperties::ExternalSemaphoreProperties(const ExternalSemaphoreProperties& copy_src) {
+    sType = copy_src.sType;
+    exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes;
+    compatibleHandleTypes = copy_src.compatibleHandleTypes;
+    externalSemaphoreFeatures = copy_src.externalSemaphoreFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExternalSemaphoreProperties& ExternalSemaphoreProperties::operator=(const ExternalSemaphoreProperties& 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;
+}
+
+ExternalSemaphoreProperties::~ExternalSemaphoreProperties() { FreePnextChain(pNext); }
+
+void ExternalSemaphoreProperties::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 ExternalSemaphoreProperties::initialize(const ExternalSemaphoreProperties* 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);
+}
+
+PhysicalDeviceMaintenance3Properties::PhysicalDeviceMaintenance3Properties(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);
+    }
+}
+
+PhysicalDeviceMaintenance3Properties::PhysicalDeviceMaintenance3Properties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES),
+      pNext(nullptr),
+      maxPerSetDescriptors(),
+      maxMemoryAllocationSize() {}
+
+PhysicalDeviceMaintenance3Properties::PhysicalDeviceMaintenance3Properties(const PhysicalDeviceMaintenance3Properties& copy_src) {
+    sType = copy_src.sType;
+    maxPerSetDescriptors = copy_src.maxPerSetDescriptors;
+    maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMaintenance3Properties& PhysicalDeviceMaintenance3Properties::operator=(
+    const PhysicalDeviceMaintenance3Properties& 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;
+}
+
+PhysicalDeviceMaintenance3Properties::~PhysicalDeviceMaintenance3Properties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMaintenance3Properties::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 PhysicalDeviceMaintenance3Properties::initialize(const PhysicalDeviceMaintenance3Properties* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxPerSetDescriptors = copy_src->maxPerSetDescriptors;
+    maxMemoryAllocationSize = copy_src->maxMemoryAllocationSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DescriptorSetLayoutSupport::DescriptorSetLayoutSupport(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);
+    }
+}
+
+DescriptorSetLayoutSupport::DescriptorSetLayoutSupport()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT), pNext(nullptr), supported() {}
+
+DescriptorSetLayoutSupport::DescriptorSetLayoutSupport(const DescriptorSetLayoutSupport& copy_src) {
+    sType = copy_src.sType;
+    supported = copy_src.supported;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DescriptorSetLayoutSupport& DescriptorSetLayoutSupport::operator=(const DescriptorSetLayoutSupport& 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;
+}
+
+DescriptorSetLayoutSupport::~DescriptorSetLayoutSupport() { FreePnextChain(pNext); }
+
+void DescriptorSetLayoutSupport::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 DescriptorSetLayoutSupport::initialize(const DescriptorSetLayoutSupport* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    supported = copy_src->supported;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderDrawParametersFeatures::PhysicalDeviceShaderDrawParametersFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceShaderDrawParametersFeatures::PhysicalDeviceShaderDrawParametersFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES), pNext(nullptr), shaderDrawParameters() {}
+
+PhysicalDeviceShaderDrawParametersFeatures::PhysicalDeviceShaderDrawParametersFeatures(
+    const PhysicalDeviceShaderDrawParametersFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderDrawParameters = copy_src.shaderDrawParameters;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderDrawParametersFeatures& PhysicalDeviceShaderDrawParametersFeatures::operator=(
+    const PhysicalDeviceShaderDrawParametersFeatures& 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;
+}
+
+PhysicalDeviceShaderDrawParametersFeatures::~PhysicalDeviceShaderDrawParametersFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderDrawParametersFeatures::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 PhysicalDeviceShaderDrawParametersFeatures::initialize(const PhysicalDeviceShaderDrawParametersFeatures* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderDrawParameters = copy_src->shaderDrawParameters;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceVulkan11Features::PhysicalDeviceVulkan11Features(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);
+    }
+}
+
+PhysicalDeviceVulkan11Features::PhysicalDeviceVulkan11Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES),
+      pNext(nullptr),
+      storageBuffer16BitAccess(),
+      uniformAndStorageBuffer16BitAccess(),
+      storagePushConstant16(),
+      storageInputOutput16(),
+      multiview(),
+      multiviewGeometryShader(),
+      multiviewTessellationShader(),
+      variablePointersStorageBuffer(),
+      variablePointers(),
+      protectedMemory(),
+      samplerYcbcrConversion(),
+      shaderDrawParameters() {}
+
+PhysicalDeviceVulkan11Features::PhysicalDeviceVulkan11Features(const PhysicalDeviceVulkan11Features& 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);
+}
+
+PhysicalDeviceVulkan11Features& PhysicalDeviceVulkan11Features::operator=(const PhysicalDeviceVulkan11Features& 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;
+}
+
+PhysicalDeviceVulkan11Features::~PhysicalDeviceVulkan11Features() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVulkan11Features::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 PhysicalDeviceVulkan11Features::initialize(const PhysicalDeviceVulkan11Features* 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);
+}
+
+PhysicalDeviceVulkan11Properties::PhysicalDeviceVulkan11Properties(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];
+    }
+}
+
+PhysicalDeviceVulkan11Properties::PhysicalDeviceVulkan11Properties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES),
+      pNext(nullptr),
+      deviceNodeMask(),
+      deviceLUIDValid(),
+      subgroupSize(),
+      subgroupSupportedStages(),
+      subgroupSupportedOperations(),
+      subgroupQuadOperationsInAllStages(),
+      pointClippingBehavior(),
+      maxMultiviewViewCount(),
+      maxMultiviewInstanceIndex(),
+      protectedNoFault(),
+      maxPerSetDescriptors(),
+      maxMemoryAllocationSize() {}
+
+PhysicalDeviceVulkan11Properties::PhysicalDeviceVulkan11Properties(const PhysicalDeviceVulkan11Properties& 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];
+    }
+}
+
+PhysicalDeviceVulkan11Properties& PhysicalDeviceVulkan11Properties::operator=(const PhysicalDeviceVulkan11Properties& 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;
+}
+
+PhysicalDeviceVulkan11Properties::~PhysicalDeviceVulkan11Properties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVulkan11Properties::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 PhysicalDeviceVulkan11Properties::initialize(const PhysicalDeviceVulkan11Properties* 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];
+    }
+}
+
+PhysicalDeviceVulkan12Features::PhysicalDeviceVulkan12Features(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);
+    }
+}
+
+PhysicalDeviceVulkan12Features::PhysicalDeviceVulkan12Features()
+    : 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() {}
+
+PhysicalDeviceVulkan12Features::PhysicalDeviceVulkan12Features(const PhysicalDeviceVulkan12Features& 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);
+}
+
+PhysicalDeviceVulkan12Features& PhysicalDeviceVulkan12Features::operator=(const PhysicalDeviceVulkan12Features& 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;
+}
+
+PhysicalDeviceVulkan12Features::~PhysicalDeviceVulkan12Features() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVulkan12Features::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 PhysicalDeviceVulkan12Features::initialize(const PhysicalDeviceVulkan12Features* 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);
+}
+
+PhysicalDeviceVulkan12Properties::PhysicalDeviceVulkan12Properties(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];
+    }
+}
+
+PhysicalDeviceVulkan12Properties::PhysicalDeviceVulkan12Properties()
+    : 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() {}
+
+PhysicalDeviceVulkan12Properties::PhysicalDeviceVulkan12Properties(const PhysicalDeviceVulkan12Properties& 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];
+    }
+}
+
+PhysicalDeviceVulkan12Properties& PhysicalDeviceVulkan12Properties::operator=(const PhysicalDeviceVulkan12Properties& 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;
+}
+
+PhysicalDeviceVulkan12Properties::~PhysicalDeviceVulkan12Properties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVulkan12Properties::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 PhysicalDeviceVulkan12Properties::initialize(const PhysicalDeviceVulkan12Properties* 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];
+    }
+}
+
+ImageFormatListCreateInfo::ImageFormatListCreateInfo(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);
+    }
+}
+
+ImageFormatListCreateInfo::ImageFormatListCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO), pNext(nullptr), viewFormatCount(), pViewFormats(nullptr) {}
+
+ImageFormatListCreateInfo::ImageFormatListCreateInfo(const ImageFormatListCreateInfo& 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);
+    }
+}
+
+ImageFormatListCreateInfo& ImageFormatListCreateInfo::operator=(const ImageFormatListCreateInfo& 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;
+}
+
+ImageFormatListCreateInfo::~ImageFormatListCreateInfo() {
+    if (pViewFormats) delete[] pViewFormats;
+    FreePnextChain(pNext);
+}
+
+void ImageFormatListCreateInfo::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 ImageFormatListCreateInfo::initialize(const ImageFormatListCreateInfo* 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);
+    }
+}
+
+AttachmentDescription2::AttachmentDescription2(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);
+    }
+}
+
+AttachmentDescription2::AttachmentDescription2()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2),
+      pNext(nullptr),
+      flags(),
+      format(),
+      samples(),
+      loadOp(),
+      storeOp(),
+      stencilLoadOp(),
+      stencilStoreOp(),
+      initialLayout(),
+      finalLayout() {}
+
+AttachmentDescription2::AttachmentDescription2(const AttachmentDescription2& 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);
+}
+
+AttachmentDescription2& AttachmentDescription2::operator=(const AttachmentDescription2& 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;
+}
+
+AttachmentDescription2::~AttachmentDescription2() { FreePnextChain(pNext); }
+
+void AttachmentDescription2::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 AttachmentDescription2::initialize(const AttachmentDescription2* 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);
+}
+
+AttachmentReference2::AttachmentReference2(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);
+    }
+}
+
+AttachmentReference2::AttachmentReference2()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2), pNext(nullptr), attachment(), layout(), aspectMask() {}
+
+AttachmentReference2::AttachmentReference2(const AttachmentReference2& copy_src) {
+    sType = copy_src.sType;
+    attachment = copy_src.attachment;
+    layout = copy_src.layout;
+    aspectMask = copy_src.aspectMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AttachmentReference2& AttachmentReference2::operator=(const AttachmentReference2& 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;
+}
+
+AttachmentReference2::~AttachmentReference2() { FreePnextChain(pNext); }
+
+void AttachmentReference2::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 AttachmentReference2::initialize(const AttachmentReference2* 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);
+}
+
+SubpassDescription2::SubpassDescription2(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 AttachmentReference2[inputAttachmentCount];
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
+            pInputAttachments[i].initialize(&in_struct->pInputAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && in_struct->pColorAttachments) {
+        pColorAttachments = new AttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && in_struct->pResolveAttachments) {
+        pResolveAttachments = new AttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pResolveAttachments[i].initialize(&in_struct->pResolveAttachments[i]);
+        }
+    }
+    if (in_struct->pDepthStencilAttachment) pDepthStencilAttachment = new AttachmentReference2(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);
+    }
+}
+
+SubpassDescription2::SubpassDescription2()
+    : 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) {}
+
+SubpassDescription2::SubpassDescription2(const SubpassDescription2& 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 AttachmentReference2[inputAttachmentCount];
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
+            pInputAttachments[i].initialize(&copy_src.pInputAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src.pColorAttachments) {
+        pColorAttachments = new AttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src.pColorAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src.pResolveAttachments) {
+        pResolveAttachments = new AttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pResolveAttachments[i].initialize(&copy_src.pResolveAttachments[i]);
+        }
+    }
+    if (copy_src.pDepthStencilAttachment) pDepthStencilAttachment = new AttachmentReference2(*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);
+    }
+}
+
+SubpassDescription2& SubpassDescription2::operator=(const SubpassDescription2& 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 AttachmentReference2[inputAttachmentCount];
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
+            pInputAttachments[i].initialize(&copy_src.pInputAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src.pColorAttachments) {
+        pColorAttachments = new AttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src.pColorAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src.pResolveAttachments) {
+        pResolveAttachments = new AttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pResolveAttachments[i].initialize(&copy_src.pResolveAttachments[i]);
+        }
+    }
+    if (copy_src.pDepthStencilAttachment) pDepthStencilAttachment = new AttachmentReference2(*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;
+}
+
+SubpassDescription2::~SubpassDescription2() {
+    if (pInputAttachments) delete[] pInputAttachments;
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pResolveAttachments) delete[] pResolveAttachments;
+    if (pDepthStencilAttachment) delete pDepthStencilAttachment;
+    if (pPreserveAttachments) delete[] pPreserveAttachments;
+    FreePnextChain(pNext);
+}
+
+void SubpassDescription2::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 AttachmentReference2[inputAttachmentCount];
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
+            pInputAttachments[i].initialize(&in_struct->pInputAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && in_struct->pColorAttachments) {
+        pColorAttachments = new AttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && in_struct->pResolveAttachments) {
+        pResolveAttachments = new AttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pResolveAttachments[i].initialize(&in_struct->pResolveAttachments[i]);
+        }
+    }
+    if (in_struct->pDepthStencilAttachment) pDepthStencilAttachment = new AttachmentReference2(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 SubpassDescription2::initialize(const SubpassDescription2* 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 AttachmentReference2[inputAttachmentCount];
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
+            pInputAttachments[i].initialize(&copy_src->pInputAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src->pColorAttachments) {
+        pColorAttachments = new AttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src->pColorAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src->pResolveAttachments) {
+        pResolveAttachments = new AttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pResolveAttachments[i].initialize(&copy_src->pResolveAttachments[i]);
+        }
+    }
+    if (copy_src->pDepthStencilAttachment) pDepthStencilAttachment = new AttachmentReference2(*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);
+    }
+}
+
+SubpassDependency2::SubpassDependency2(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);
+    }
+}
+
+SubpassDependency2::SubpassDependency2()
+    : sType(VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2),
+      pNext(nullptr),
+      srcSubpass(),
+      dstSubpass(),
+      srcStageMask(),
+      dstStageMask(),
+      srcAccessMask(),
+      dstAccessMask(),
+      dependencyFlags(),
+      viewOffset() {}
+
+SubpassDependency2::SubpassDependency2(const SubpassDependency2& 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);
+}
+
+SubpassDependency2& SubpassDependency2::operator=(const SubpassDependency2& 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;
+}
+
+SubpassDependency2::~SubpassDependency2() { FreePnextChain(pNext); }
+
+void SubpassDependency2::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 SubpassDependency2::initialize(const SubpassDependency2* 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);
+}
+
+RenderPassCreateInfo2::RenderPassCreateInfo2(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 AttachmentDescription2[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i].initialize(&in_struct->pAttachments[i]);
+        }
+    }
+    if (subpassCount && in_struct->pSubpasses) {
+        pSubpasses = new SubpassDescription2[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
+        }
+    }
+    if (dependencyCount && in_struct->pDependencies) {
+        pDependencies = new SubpassDependency2[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);
+    }
+}
+
+RenderPassCreateInfo2::RenderPassCreateInfo2()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2),
+      pNext(nullptr),
+      flags(),
+      attachmentCount(),
+      pAttachments(nullptr),
+      subpassCount(),
+      pSubpasses(nullptr),
+      dependencyCount(),
+      pDependencies(nullptr),
+      correlatedViewMaskCount(),
+      pCorrelatedViewMasks(nullptr) {}
+
+RenderPassCreateInfo2::RenderPassCreateInfo2(const RenderPassCreateInfo2& 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 AttachmentDescription2[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i].initialize(&copy_src.pAttachments[i]);
+        }
+    }
+    if (subpassCount && copy_src.pSubpasses) {
+        pSubpasses = new SubpassDescription2[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&copy_src.pSubpasses[i]);
+        }
+    }
+    if (dependencyCount && copy_src.pDependencies) {
+        pDependencies = new SubpassDependency2[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);
+    }
+}
+
+RenderPassCreateInfo2& RenderPassCreateInfo2::operator=(const RenderPassCreateInfo2& 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 AttachmentDescription2[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i].initialize(&copy_src.pAttachments[i]);
+        }
+    }
+    if (subpassCount && copy_src.pSubpasses) {
+        pSubpasses = new SubpassDescription2[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&copy_src.pSubpasses[i]);
+        }
+    }
+    if (dependencyCount && copy_src.pDependencies) {
+        pDependencies = new SubpassDependency2[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;
+}
+
+RenderPassCreateInfo2::~RenderPassCreateInfo2() {
+    if (pAttachments) delete[] pAttachments;
+    if (pSubpasses) delete[] pSubpasses;
+    if (pDependencies) delete[] pDependencies;
+    if (pCorrelatedViewMasks) delete[] pCorrelatedViewMasks;
+    FreePnextChain(pNext);
+}
+
+void RenderPassCreateInfo2::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 AttachmentDescription2[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i].initialize(&in_struct->pAttachments[i]);
+        }
+    }
+    if (subpassCount && in_struct->pSubpasses) {
+        pSubpasses = new SubpassDescription2[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
+        }
+    }
+    if (dependencyCount && in_struct->pDependencies) {
+        pDependencies = new SubpassDependency2[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 RenderPassCreateInfo2::initialize(const RenderPassCreateInfo2* 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 AttachmentDescription2[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i].initialize(&copy_src->pAttachments[i]);
+        }
+    }
+    if (subpassCount && copy_src->pSubpasses) {
+        pSubpasses = new SubpassDescription2[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&copy_src->pSubpasses[i]);
+        }
+    }
+    if (dependencyCount && copy_src->pDependencies) {
+        pDependencies = new SubpassDependency2[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);
+    }
+}
+
+SubpassBeginInfo::SubpassBeginInfo(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);
+    }
+}
+
+SubpassBeginInfo::SubpassBeginInfo() : sType(VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO), pNext(nullptr), contents() {}
+
+SubpassBeginInfo::SubpassBeginInfo(const SubpassBeginInfo& copy_src) {
+    sType = copy_src.sType;
+    contents = copy_src.contents;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SubpassBeginInfo& SubpassBeginInfo::operator=(const SubpassBeginInfo& 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;
+}
+
+SubpassBeginInfo::~SubpassBeginInfo() { FreePnextChain(pNext); }
+
+void SubpassBeginInfo::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 SubpassBeginInfo::initialize(const SubpassBeginInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    contents = copy_src->contents;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SubpassEndInfo::SubpassEndInfo(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);
+    }
+}
+
+SubpassEndInfo::SubpassEndInfo() : sType(VK_STRUCTURE_TYPE_SUBPASS_END_INFO), pNext(nullptr) {}
+
+SubpassEndInfo::SubpassEndInfo(const SubpassEndInfo& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SubpassEndInfo& SubpassEndInfo::operator=(const SubpassEndInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+SubpassEndInfo::~SubpassEndInfo() { FreePnextChain(pNext); }
+
+void SubpassEndInfo::initialize(const VkSubpassEndInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void SubpassEndInfo::initialize(const SubpassEndInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevice8BitStorageFeatures::PhysicalDevice8BitStorageFeatures(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);
+    }
+}
+
+PhysicalDevice8BitStorageFeatures::PhysicalDevice8BitStorageFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES),
+      pNext(nullptr),
+      storageBuffer8BitAccess(),
+      uniformAndStorageBuffer8BitAccess(),
+      storagePushConstant8() {}
+
+PhysicalDevice8BitStorageFeatures::PhysicalDevice8BitStorageFeatures(const PhysicalDevice8BitStorageFeatures& copy_src) {
+    sType = copy_src.sType;
+    storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess;
+    uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess;
+    storagePushConstant8 = copy_src.storagePushConstant8;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevice8BitStorageFeatures& PhysicalDevice8BitStorageFeatures::operator=(const PhysicalDevice8BitStorageFeatures& 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;
+}
+
+PhysicalDevice8BitStorageFeatures::~PhysicalDevice8BitStorageFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDevice8BitStorageFeatures::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 PhysicalDevice8BitStorageFeatures::initialize(const PhysicalDevice8BitStorageFeatures* 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);
+}
+
+PhysicalDeviceDriverProperties::PhysicalDeviceDriverProperties(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];
+    }
+}
+
+PhysicalDeviceDriverProperties::PhysicalDeviceDriverProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES), pNext(nullptr), driverID(), conformanceVersion() {}
+
+PhysicalDeviceDriverProperties::PhysicalDeviceDriverProperties(const PhysicalDeviceDriverProperties& 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];
+    }
+}
+
+PhysicalDeviceDriverProperties& PhysicalDeviceDriverProperties::operator=(const PhysicalDeviceDriverProperties& 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;
+}
+
+PhysicalDeviceDriverProperties::~PhysicalDeviceDriverProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDriverProperties::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 PhysicalDeviceDriverProperties::initialize(const PhysicalDeviceDriverProperties* 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];
+    }
+}
+
+PhysicalDeviceShaderAtomicInt64Features::PhysicalDeviceShaderAtomicInt64Features(
+    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);
+    }
+}
+
+PhysicalDeviceShaderAtomicInt64Features::PhysicalDeviceShaderAtomicInt64Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES),
+      pNext(nullptr),
+      shaderBufferInt64Atomics(),
+      shaderSharedInt64Atomics() {}
+
+PhysicalDeviceShaderAtomicInt64Features::PhysicalDeviceShaderAtomicInt64Features(
+    const PhysicalDeviceShaderAtomicInt64Features& copy_src) {
+    sType = copy_src.sType;
+    shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics;
+    shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderAtomicInt64Features& PhysicalDeviceShaderAtomicInt64Features::operator=(
+    const PhysicalDeviceShaderAtomicInt64Features& 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;
+}
+
+PhysicalDeviceShaderAtomicInt64Features::~PhysicalDeviceShaderAtomicInt64Features() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderAtomicInt64Features::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 PhysicalDeviceShaderAtomicInt64Features::initialize(const PhysicalDeviceShaderAtomicInt64Features* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderBufferInt64Atomics = copy_src->shaderBufferInt64Atomics;
+    shaderSharedInt64Atomics = copy_src->shaderSharedInt64Atomics;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderFloat16Int8Features::PhysicalDeviceShaderFloat16Int8Features(
+    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);
+    }
+}
+
+PhysicalDeviceShaderFloat16Int8Features::PhysicalDeviceShaderFloat16Int8Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES), pNext(nullptr), shaderFloat16(), shaderInt8() {}
+
+PhysicalDeviceShaderFloat16Int8Features::PhysicalDeviceShaderFloat16Int8Features(
+    const PhysicalDeviceShaderFloat16Int8Features& copy_src) {
+    sType = copy_src.sType;
+    shaderFloat16 = copy_src.shaderFloat16;
+    shaderInt8 = copy_src.shaderInt8;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderFloat16Int8Features& PhysicalDeviceShaderFloat16Int8Features::operator=(
+    const PhysicalDeviceShaderFloat16Int8Features& 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;
+}
+
+PhysicalDeviceShaderFloat16Int8Features::~PhysicalDeviceShaderFloat16Int8Features() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderFloat16Int8Features::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 PhysicalDeviceShaderFloat16Int8Features::initialize(const PhysicalDeviceShaderFloat16Int8Features* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderFloat16 = copy_src->shaderFloat16;
+    shaderInt8 = copy_src->shaderInt8;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceFloatControlsProperties::PhysicalDeviceFloatControlsProperties(
+    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);
+    }
+}
+
+PhysicalDeviceFloatControlsProperties::PhysicalDeviceFloatControlsProperties()
+    : 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() {}
+
+PhysicalDeviceFloatControlsProperties::PhysicalDeviceFloatControlsProperties(
+    const PhysicalDeviceFloatControlsProperties& 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);
+}
+
+PhysicalDeviceFloatControlsProperties& PhysicalDeviceFloatControlsProperties::operator=(
+    const PhysicalDeviceFloatControlsProperties& 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;
+}
+
+PhysicalDeviceFloatControlsProperties::~PhysicalDeviceFloatControlsProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFloatControlsProperties::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 PhysicalDeviceFloatControlsProperties::initialize(const PhysicalDeviceFloatControlsProperties* 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);
+}
+
+DescriptorSetLayoutBindingFlagsCreateInfo::DescriptorSetLayoutBindingFlagsCreateInfo(
+    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);
+    }
+}
+
+DescriptorSetLayoutBindingFlagsCreateInfo::DescriptorSetLayoutBindingFlagsCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO),
+      pNext(nullptr),
+      bindingCount(),
+      pBindingFlags(nullptr) {}
+
+DescriptorSetLayoutBindingFlagsCreateInfo::DescriptorSetLayoutBindingFlagsCreateInfo(
+    const DescriptorSetLayoutBindingFlagsCreateInfo& 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);
+    }
+}
+
+DescriptorSetLayoutBindingFlagsCreateInfo& DescriptorSetLayoutBindingFlagsCreateInfo::operator=(
+    const DescriptorSetLayoutBindingFlagsCreateInfo& 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;
+}
+
+DescriptorSetLayoutBindingFlagsCreateInfo::~DescriptorSetLayoutBindingFlagsCreateInfo() {
+    if (pBindingFlags) delete[] pBindingFlags;
+    FreePnextChain(pNext);
+}
+
+void DescriptorSetLayoutBindingFlagsCreateInfo::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 DescriptorSetLayoutBindingFlagsCreateInfo::initialize(const DescriptorSetLayoutBindingFlagsCreateInfo* 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);
+    }
+}
+
+PhysicalDeviceDescriptorIndexingFeatures::PhysicalDeviceDescriptorIndexingFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceDescriptorIndexingFeatures::PhysicalDeviceDescriptorIndexingFeatures()
+    : 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() {}
+
+PhysicalDeviceDescriptorIndexingFeatures::PhysicalDeviceDescriptorIndexingFeatures(
+    const PhysicalDeviceDescriptorIndexingFeatures& 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);
+}
+
+PhysicalDeviceDescriptorIndexingFeatures& PhysicalDeviceDescriptorIndexingFeatures::operator=(
+    const PhysicalDeviceDescriptorIndexingFeatures& 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;
+}
+
+PhysicalDeviceDescriptorIndexingFeatures::~PhysicalDeviceDescriptorIndexingFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDescriptorIndexingFeatures::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 PhysicalDeviceDescriptorIndexingFeatures::initialize(const PhysicalDeviceDescriptorIndexingFeatures* 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);
+}
+
+PhysicalDeviceDescriptorIndexingProperties::PhysicalDeviceDescriptorIndexingProperties(
+    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);
+    }
+}
+
+PhysicalDeviceDescriptorIndexingProperties::PhysicalDeviceDescriptorIndexingProperties()
+    : 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() {}
+
+PhysicalDeviceDescriptorIndexingProperties::PhysicalDeviceDescriptorIndexingProperties(
+    const PhysicalDeviceDescriptorIndexingProperties& 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);
+}
+
+PhysicalDeviceDescriptorIndexingProperties& PhysicalDeviceDescriptorIndexingProperties::operator=(
+    const PhysicalDeviceDescriptorIndexingProperties& 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;
+}
+
+PhysicalDeviceDescriptorIndexingProperties::~PhysicalDeviceDescriptorIndexingProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDescriptorIndexingProperties::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 PhysicalDeviceDescriptorIndexingProperties::initialize(const PhysicalDeviceDescriptorIndexingProperties* 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);
+}
+
+DescriptorSetVariableDescriptorCountAllocateInfo::DescriptorSetVariableDescriptorCountAllocateInfo(
+    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);
+    }
+}
+
+DescriptorSetVariableDescriptorCountAllocateInfo::DescriptorSetVariableDescriptorCountAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO),
+      pNext(nullptr),
+      descriptorSetCount(),
+      pDescriptorCounts(nullptr) {}
+
+DescriptorSetVariableDescriptorCountAllocateInfo::DescriptorSetVariableDescriptorCountAllocateInfo(
+    const DescriptorSetVariableDescriptorCountAllocateInfo& 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);
+    }
+}
+
+DescriptorSetVariableDescriptorCountAllocateInfo& DescriptorSetVariableDescriptorCountAllocateInfo::operator=(
+    const DescriptorSetVariableDescriptorCountAllocateInfo& 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;
+}
+
+DescriptorSetVariableDescriptorCountAllocateInfo::~DescriptorSetVariableDescriptorCountAllocateInfo() {
+    if (pDescriptorCounts) delete[] pDescriptorCounts;
+    FreePnextChain(pNext);
+}
+
+void DescriptorSetVariableDescriptorCountAllocateInfo::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 DescriptorSetVariableDescriptorCountAllocateInfo::initialize(const DescriptorSetVariableDescriptorCountAllocateInfo* 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);
+    }
+}
+
+DescriptorSetVariableDescriptorCountLayoutSupport::DescriptorSetVariableDescriptorCountLayoutSupport(
+    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);
+    }
+}
+
+DescriptorSetVariableDescriptorCountLayoutSupport::DescriptorSetVariableDescriptorCountLayoutSupport()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT),
+      pNext(nullptr),
+      maxVariableDescriptorCount() {}
+
+DescriptorSetVariableDescriptorCountLayoutSupport::DescriptorSetVariableDescriptorCountLayoutSupport(
+    const DescriptorSetVariableDescriptorCountLayoutSupport& copy_src) {
+    sType = copy_src.sType;
+    maxVariableDescriptorCount = copy_src.maxVariableDescriptorCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DescriptorSetVariableDescriptorCountLayoutSupport& DescriptorSetVariableDescriptorCountLayoutSupport::operator=(
+    const DescriptorSetVariableDescriptorCountLayoutSupport& 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;
+}
+
+DescriptorSetVariableDescriptorCountLayoutSupport::~DescriptorSetVariableDescriptorCountLayoutSupport() { FreePnextChain(pNext); }
+
+void DescriptorSetVariableDescriptorCountLayoutSupport::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 DescriptorSetVariableDescriptorCountLayoutSupport::initialize(
+    const DescriptorSetVariableDescriptorCountLayoutSupport* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxVariableDescriptorCount = copy_src->maxVariableDescriptorCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SubpassDescriptionDepthStencilResolve::SubpassDescriptionDepthStencilResolve(
+    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 AttachmentReference2(in_struct->pDepthStencilResolveAttachment);
+}
+
+SubpassDescriptionDepthStencilResolve::SubpassDescriptionDepthStencilResolve()
+    : sType(VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE),
+      pNext(nullptr),
+      depthResolveMode(),
+      stencilResolveMode(),
+      pDepthStencilResolveAttachment(nullptr) {}
+
+SubpassDescriptionDepthStencilResolve::SubpassDescriptionDepthStencilResolve(
+    const SubpassDescriptionDepthStencilResolve& 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 AttachmentReference2(*copy_src.pDepthStencilResolveAttachment);
+}
+
+SubpassDescriptionDepthStencilResolve& SubpassDescriptionDepthStencilResolve::operator=(
+    const SubpassDescriptionDepthStencilResolve& 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 AttachmentReference2(*copy_src.pDepthStencilResolveAttachment);
+
+    return *this;
+}
+
+SubpassDescriptionDepthStencilResolve::~SubpassDescriptionDepthStencilResolve() {
+    if (pDepthStencilResolveAttachment) delete pDepthStencilResolveAttachment;
+    FreePnextChain(pNext);
+}
+
+void SubpassDescriptionDepthStencilResolve::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 AttachmentReference2(in_struct->pDepthStencilResolveAttachment);
+}
+
+void SubpassDescriptionDepthStencilResolve::initialize(const SubpassDescriptionDepthStencilResolve* 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 AttachmentReference2(*copy_src->pDepthStencilResolveAttachment);
+}
+
+PhysicalDeviceDepthStencilResolveProperties::PhysicalDeviceDepthStencilResolveProperties(
+    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);
+    }
+}
+
+PhysicalDeviceDepthStencilResolveProperties::PhysicalDeviceDepthStencilResolveProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES),
+      pNext(nullptr),
+      supportedDepthResolveModes(),
+      supportedStencilResolveModes(),
+      independentResolveNone(),
+      independentResolve() {}
+
+PhysicalDeviceDepthStencilResolveProperties::PhysicalDeviceDepthStencilResolveProperties(
+    const PhysicalDeviceDepthStencilResolveProperties& 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);
+}
+
+PhysicalDeviceDepthStencilResolveProperties& PhysicalDeviceDepthStencilResolveProperties::operator=(
+    const PhysicalDeviceDepthStencilResolveProperties& 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;
+}
+
+PhysicalDeviceDepthStencilResolveProperties::~PhysicalDeviceDepthStencilResolveProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDepthStencilResolveProperties::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 PhysicalDeviceDepthStencilResolveProperties::initialize(const PhysicalDeviceDepthStencilResolveProperties* 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);
+}
+
+PhysicalDeviceScalarBlockLayoutFeatures::PhysicalDeviceScalarBlockLayoutFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceScalarBlockLayoutFeatures::PhysicalDeviceScalarBlockLayoutFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES), pNext(nullptr), scalarBlockLayout() {}
+
+PhysicalDeviceScalarBlockLayoutFeatures::PhysicalDeviceScalarBlockLayoutFeatures(
+    const PhysicalDeviceScalarBlockLayoutFeatures& copy_src) {
+    sType = copy_src.sType;
+    scalarBlockLayout = copy_src.scalarBlockLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceScalarBlockLayoutFeatures& PhysicalDeviceScalarBlockLayoutFeatures::operator=(
+    const PhysicalDeviceScalarBlockLayoutFeatures& 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;
+}
+
+PhysicalDeviceScalarBlockLayoutFeatures::~PhysicalDeviceScalarBlockLayoutFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceScalarBlockLayoutFeatures::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 PhysicalDeviceScalarBlockLayoutFeatures::initialize(const PhysicalDeviceScalarBlockLayoutFeatures* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    scalarBlockLayout = copy_src->scalarBlockLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImageStencilUsageCreateInfo::ImageStencilUsageCreateInfo(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);
+    }
+}
+
+ImageStencilUsageCreateInfo::ImageStencilUsageCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO), pNext(nullptr), stencilUsage() {}
+
+ImageStencilUsageCreateInfo::ImageStencilUsageCreateInfo(const ImageStencilUsageCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    stencilUsage = copy_src.stencilUsage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageStencilUsageCreateInfo& ImageStencilUsageCreateInfo::operator=(const ImageStencilUsageCreateInfo& 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;
+}
+
+ImageStencilUsageCreateInfo::~ImageStencilUsageCreateInfo() { FreePnextChain(pNext); }
+
+void ImageStencilUsageCreateInfo::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 ImageStencilUsageCreateInfo::initialize(const ImageStencilUsageCreateInfo* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stencilUsage = copy_src->stencilUsage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SamplerReductionModeCreateInfo::SamplerReductionModeCreateInfo(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);
+    }
+}
+
+SamplerReductionModeCreateInfo::SamplerReductionModeCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO), pNext(nullptr), reductionMode() {}
+
+SamplerReductionModeCreateInfo::SamplerReductionModeCreateInfo(const SamplerReductionModeCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    reductionMode = copy_src.reductionMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SamplerReductionModeCreateInfo& SamplerReductionModeCreateInfo::operator=(const SamplerReductionModeCreateInfo& 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;
+}
+
+SamplerReductionModeCreateInfo::~SamplerReductionModeCreateInfo() { FreePnextChain(pNext); }
+
+void SamplerReductionModeCreateInfo::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 SamplerReductionModeCreateInfo::initialize(const SamplerReductionModeCreateInfo* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    reductionMode = copy_src->reductionMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceSamplerFilterMinmaxProperties::PhysicalDeviceSamplerFilterMinmaxProperties(
+    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);
+    }
+}
+
+PhysicalDeviceSamplerFilterMinmaxProperties::PhysicalDeviceSamplerFilterMinmaxProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES),
+      pNext(nullptr),
+      filterMinmaxSingleComponentFormats(),
+      filterMinmaxImageComponentMapping() {}
+
+PhysicalDeviceSamplerFilterMinmaxProperties::PhysicalDeviceSamplerFilterMinmaxProperties(
+    const PhysicalDeviceSamplerFilterMinmaxProperties& copy_src) {
+    sType = copy_src.sType;
+    filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats;
+    filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSamplerFilterMinmaxProperties& PhysicalDeviceSamplerFilterMinmaxProperties::operator=(
+    const PhysicalDeviceSamplerFilterMinmaxProperties& 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;
+}
+
+PhysicalDeviceSamplerFilterMinmaxProperties::~PhysicalDeviceSamplerFilterMinmaxProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSamplerFilterMinmaxProperties::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 PhysicalDeviceSamplerFilterMinmaxProperties::initialize(const PhysicalDeviceSamplerFilterMinmaxProperties* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    filterMinmaxSingleComponentFormats = copy_src->filterMinmaxSingleComponentFormats;
+    filterMinmaxImageComponentMapping = copy_src->filterMinmaxImageComponentMapping;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceVulkanMemoryModelFeatures::PhysicalDeviceVulkanMemoryModelFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceVulkanMemoryModelFeatures::PhysicalDeviceVulkanMemoryModelFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES),
+      pNext(nullptr),
+      vulkanMemoryModel(),
+      vulkanMemoryModelDeviceScope(),
+      vulkanMemoryModelAvailabilityVisibilityChains() {}
+
+PhysicalDeviceVulkanMemoryModelFeatures::PhysicalDeviceVulkanMemoryModelFeatures(
+    const PhysicalDeviceVulkanMemoryModelFeatures& copy_src) {
+    sType = copy_src.sType;
+    vulkanMemoryModel = copy_src.vulkanMemoryModel;
+    vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope;
+    vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceVulkanMemoryModelFeatures& PhysicalDeviceVulkanMemoryModelFeatures::operator=(
+    const PhysicalDeviceVulkanMemoryModelFeatures& 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;
+}
+
+PhysicalDeviceVulkanMemoryModelFeatures::~PhysicalDeviceVulkanMemoryModelFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVulkanMemoryModelFeatures::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 PhysicalDeviceVulkanMemoryModelFeatures::initialize(const PhysicalDeviceVulkanMemoryModelFeatures* 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);
+}
+
+PhysicalDeviceImagelessFramebufferFeatures::PhysicalDeviceImagelessFramebufferFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceImagelessFramebufferFeatures::PhysicalDeviceImagelessFramebufferFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES), pNext(nullptr), imagelessFramebuffer() {}
+
+PhysicalDeviceImagelessFramebufferFeatures::PhysicalDeviceImagelessFramebufferFeatures(
+    const PhysicalDeviceImagelessFramebufferFeatures& copy_src) {
+    sType = copy_src.sType;
+    imagelessFramebuffer = copy_src.imagelessFramebuffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceImagelessFramebufferFeatures& PhysicalDeviceImagelessFramebufferFeatures::operator=(
+    const PhysicalDeviceImagelessFramebufferFeatures& 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;
+}
+
+PhysicalDeviceImagelessFramebufferFeatures::~PhysicalDeviceImagelessFramebufferFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImagelessFramebufferFeatures::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 PhysicalDeviceImagelessFramebufferFeatures::initialize(const PhysicalDeviceImagelessFramebufferFeatures* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imagelessFramebuffer = copy_src->imagelessFramebuffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+FramebufferAttachmentImageInfo::FramebufferAttachmentImageInfo(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);
+    }
+}
+
+FramebufferAttachmentImageInfo::FramebufferAttachmentImageInfo()
+    : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO),
+      pNext(nullptr),
+      flags(),
+      usage(),
+      width(),
+      height(),
+      layerCount(),
+      viewFormatCount(),
+      pViewFormats(nullptr) {}
+
+FramebufferAttachmentImageInfo::FramebufferAttachmentImageInfo(const FramebufferAttachmentImageInfo& 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);
+    }
+}
+
+FramebufferAttachmentImageInfo& FramebufferAttachmentImageInfo::operator=(const FramebufferAttachmentImageInfo& 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;
+}
+
+FramebufferAttachmentImageInfo::~FramebufferAttachmentImageInfo() {
+    if (pViewFormats) delete[] pViewFormats;
+    FreePnextChain(pNext);
+}
+
+void FramebufferAttachmentImageInfo::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 FramebufferAttachmentImageInfo::initialize(const FramebufferAttachmentImageInfo* 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);
+    }
+}
+
+FramebufferAttachmentsCreateInfo::FramebufferAttachmentsCreateInfo(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 FramebufferAttachmentImageInfo[attachmentImageInfoCount];
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
+            pAttachmentImageInfos[i].initialize(&in_struct->pAttachmentImageInfos[i]);
+        }
+    }
+}
+
+FramebufferAttachmentsCreateInfo::FramebufferAttachmentsCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO),
+      pNext(nullptr),
+      attachmentImageInfoCount(),
+      pAttachmentImageInfos(nullptr) {}
+
+FramebufferAttachmentsCreateInfo::FramebufferAttachmentsCreateInfo(const FramebufferAttachmentsCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    attachmentImageInfoCount = copy_src.attachmentImageInfoCount;
+    pAttachmentImageInfos = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (attachmentImageInfoCount && copy_src.pAttachmentImageInfos) {
+        pAttachmentImageInfos = new FramebufferAttachmentImageInfo[attachmentImageInfoCount];
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
+            pAttachmentImageInfos[i].initialize(&copy_src.pAttachmentImageInfos[i]);
+        }
+    }
+}
+
+FramebufferAttachmentsCreateInfo& FramebufferAttachmentsCreateInfo::operator=(const FramebufferAttachmentsCreateInfo& 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 FramebufferAttachmentImageInfo[attachmentImageInfoCount];
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
+            pAttachmentImageInfos[i].initialize(&copy_src.pAttachmentImageInfos[i]);
+        }
+    }
+
+    return *this;
+}
+
+FramebufferAttachmentsCreateInfo::~FramebufferAttachmentsCreateInfo() {
+    if (pAttachmentImageInfos) delete[] pAttachmentImageInfos;
+    FreePnextChain(pNext);
+}
+
+void FramebufferAttachmentsCreateInfo::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 FramebufferAttachmentImageInfo[attachmentImageInfoCount];
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
+            pAttachmentImageInfos[i].initialize(&in_struct->pAttachmentImageInfos[i]);
+        }
+    }
+}
+
+void FramebufferAttachmentsCreateInfo::initialize(const FramebufferAttachmentsCreateInfo* 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 FramebufferAttachmentImageInfo[attachmentImageInfoCount];
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
+            pAttachmentImageInfos[i].initialize(&copy_src->pAttachmentImageInfos[i]);
+        }
+    }
+}
+
+RenderPassAttachmentBeginInfo::RenderPassAttachmentBeginInfo(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];
+        }
+    }
+}
+
+RenderPassAttachmentBeginInfo::RenderPassAttachmentBeginInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO), pNext(nullptr), attachmentCount(), pAttachments(nullptr) {}
+
+RenderPassAttachmentBeginInfo::RenderPassAttachmentBeginInfo(const RenderPassAttachmentBeginInfo& 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];
+        }
+    }
+}
+
+RenderPassAttachmentBeginInfo& RenderPassAttachmentBeginInfo::operator=(const RenderPassAttachmentBeginInfo& 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;
+}
+
+RenderPassAttachmentBeginInfo::~RenderPassAttachmentBeginInfo() {
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+}
+
+void RenderPassAttachmentBeginInfo::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 RenderPassAttachmentBeginInfo::initialize(const RenderPassAttachmentBeginInfo* 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];
+        }
+    }
+}
+
+PhysicalDeviceUniformBufferStandardLayoutFeatures::PhysicalDeviceUniformBufferStandardLayoutFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceUniformBufferStandardLayoutFeatures::PhysicalDeviceUniformBufferStandardLayoutFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES),
+      pNext(nullptr),
+      uniformBufferStandardLayout() {}
+
+PhysicalDeviceUniformBufferStandardLayoutFeatures::PhysicalDeviceUniformBufferStandardLayoutFeatures(
+    const PhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src) {
+    sType = copy_src.sType;
+    uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceUniformBufferStandardLayoutFeatures& PhysicalDeviceUniformBufferStandardLayoutFeatures::operator=(
+    const PhysicalDeviceUniformBufferStandardLayoutFeatures& 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;
+}
+
+PhysicalDeviceUniformBufferStandardLayoutFeatures::~PhysicalDeviceUniformBufferStandardLayoutFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceUniformBufferStandardLayoutFeatures::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 PhysicalDeviceUniformBufferStandardLayoutFeatures::initialize(
+    const PhysicalDeviceUniformBufferStandardLayoutFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    uniformBufferStandardLayout = copy_src->uniformBufferStandardLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderSubgroupExtendedTypesFeatures::PhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceShaderSubgroupExtendedTypesFeatures::PhysicalDeviceShaderSubgroupExtendedTypesFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES),
+      pNext(nullptr),
+      shaderSubgroupExtendedTypes() {}
+
+PhysicalDeviceShaderSubgroupExtendedTypesFeatures::PhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+    const PhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderSubgroupExtendedTypesFeatures& PhysicalDeviceShaderSubgroupExtendedTypesFeatures::operator=(
+    const PhysicalDeviceShaderSubgroupExtendedTypesFeatures& 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;
+}
+
+PhysicalDeviceShaderSubgroupExtendedTypesFeatures::~PhysicalDeviceShaderSubgroupExtendedTypesFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderSubgroupExtendedTypesFeatures::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 PhysicalDeviceShaderSubgroupExtendedTypesFeatures::initialize(
+    const PhysicalDeviceShaderSubgroupExtendedTypesFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSubgroupExtendedTypes = copy_src->shaderSubgroupExtendedTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceSeparateDepthStencilLayoutsFeatures::PhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceSeparateDepthStencilLayoutsFeatures::PhysicalDeviceSeparateDepthStencilLayoutsFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES),
+      pNext(nullptr),
+      separateDepthStencilLayouts() {}
+
+PhysicalDeviceSeparateDepthStencilLayoutsFeatures::PhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+    const PhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src) {
+    sType = copy_src.sType;
+    separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSeparateDepthStencilLayoutsFeatures& PhysicalDeviceSeparateDepthStencilLayoutsFeatures::operator=(
+    const PhysicalDeviceSeparateDepthStencilLayoutsFeatures& 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;
+}
+
+PhysicalDeviceSeparateDepthStencilLayoutsFeatures::~PhysicalDeviceSeparateDepthStencilLayoutsFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSeparateDepthStencilLayoutsFeatures::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 PhysicalDeviceSeparateDepthStencilLayoutsFeatures::initialize(
+    const PhysicalDeviceSeparateDepthStencilLayoutsFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    separateDepthStencilLayouts = copy_src->separateDepthStencilLayouts;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+AttachmentReferenceStencilLayout::AttachmentReferenceStencilLayout(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);
+    }
+}
+
+AttachmentReferenceStencilLayout::AttachmentReferenceStencilLayout()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT), pNext(nullptr), stencilLayout() {}
+
+AttachmentReferenceStencilLayout::AttachmentReferenceStencilLayout(const AttachmentReferenceStencilLayout& copy_src) {
+    sType = copy_src.sType;
+    stencilLayout = copy_src.stencilLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AttachmentReferenceStencilLayout& AttachmentReferenceStencilLayout::operator=(const AttachmentReferenceStencilLayout& 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;
+}
+
+AttachmentReferenceStencilLayout::~AttachmentReferenceStencilLayout() { FreePnextChain(pNext); }
+
+void AttachmentReferenceStencilLayout::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 AttachmentReferenceStencilLayout::initialize(const AttachmentReferenceStencilLayout* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stencilLayout = copy_src->stencilLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+AttachmentDescriptionStencilLayout::AttachmentDescriptionStencilLayout(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);
+    }
+}
+
+AttachmentDescriptionStencilLayout::AttachmentDescriptionStencilLayout()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT),
+      pNext(nullptr),
+      stencilInitialLayout(),
+      stencilFinalLayout() {}
+
+AttachmentDescriptionStencilLayout::AttachmentDescriptionStencilLayout(const AttachmentDescriptionStencilLayout& copy_src) {
+    sType = copy_src.sType;
+    stencilInitialLayout = copy_src.stencilInitialLayout;
+    stencilFinalLayout = copy_src.stencilFinalLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AttachmentDescriptionStencilLayout& AttachmentDescriptionStencilLayout::operator=(
+    const AttachmentDescriptionStencilLayout& 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;
+}
+
+AttachmentDescriptionStencilLayout::~AttachmentDescriptionStencilLayout() { FreePnextChain(pNext); }
+
+void AttachmentDescriptionStencilLayout::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 AttachmentDescriptionStencilLayout::initialize(const AttachmentDescriptionStencilLayout* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stencilInitialLayout = copy_src->stencilInitialLayout;
+    stencilFinalLayout = copy_src->stencilFinalLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceHostQueryResetFeatures::PhysicalDeviceHostQueryResetFeatures(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);
+    }
+}
+
+PhysicalDeviceHostQueryResetFeatures::PhysicalDeviceHostQueryResetFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES), pNext(nullptr), hostQueryReset() {}
+
+PhysicalDeviceHostQueryResetFeatures::PhysicalDeviceHostQueryResetFeatures(const PhysicalDeviceHostQueryResetFeatures& copy_src) {
+    sType = copy_src.sType;
+    hostQueryReset = copy_src.hostQueryReset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceHostQueryResetFeatures& PhysicalDeviceHostQueryResetFeatures::operator=(
+    const PhysicalDeviceHostQueryResetFeatures& 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;
+}
+
+PhysicalDeviceHostQueryResetFeatures::~PhysicalDeviceHostQueryResetFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceHostQueryResetFeatures::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 PhysicalDeviceHostQueryResetFeatures::initialize(const PhysicalDeviceHostQueryResetFeatures* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hostQueryReset = copy_src->hostQueryReset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceTimelineSemaphoreFeatures::PhysicalDeviceTimelineSemaphoreFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceTimelineSemaphoreFeatures::PhysicalDeviceTimelineSemaphoreFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES), pNext(nullptr), timelineSemaphore() {}
+
+PhysicalDeviceTimelineSemaphoreFeatures::PhysicalDeviceTimelineSemaphoreFeatures(
+    const PhysicalDeviceTimelineSemaphoreFeatures& copy_src) {
+    sType = copy_src.sType;
+    timelineSemaphore = copy_src.timelineSemaphore;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceTimelineSemaphoreFeatures& PhysicalDeviceTimelineSemaphoreFeatures::operator=(
+    const PhysicalDeviceTimelineSemaphoreFeatures& 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;
+}
+
+PhysicalDeviceTimelineSemaphoreFeatures::~PhysicalDeviceTimelineSemaphoreFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceTimelineSemaphoreFeatures::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 PhysicalDeviceTimelineSemaphoreFeatures::initialize(const PhysicalDeviceTimelineSemaphoreFeatures* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    timelineSemaphore = copy_src->timelineSemaphore;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceTimelineSemaphoreProperties::PhysicalDeviceTimelineSemaphoreProperties(
+    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);
+    }
+}
+
+PhysicalDeviceTimelineSemaphoreProperties::PhysicalDeviceTimelineSemaphoreProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES),
+      pNext(nullptr),
+      maxTimelineSemaphoreValueDifference() {}
+
+PhysicalDeviceTimelineSemaphoreProperties::PhysicalDeviceTimelineSemaphoreProperties(
+    const PhysicalDeviceTimelineSemaphoreProperties& copy_src) {
+    sType = copy_src.sType;
+    maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceTimelineSemaphoreProperties& PhysicalDeviceTimelineSemaphoreProperties::operator=(
+    const PhysicalDeviceTimelineSemaphoreProperties& 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;
+}
+
+PhysicalDeviceTimelineSemaphoreProperties::~PhysicalDeviceTimelineSemaphoreProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceTimelineSemaphoreProperties::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 PhysicalDeviceTimelineSemaphoreProperties::initialize(const PhysicalDeviceTimelineSemaphoreProperties* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxTimelineSemaphoreValueDifference = copy_src->maxTimelineSemaphoreValueDifference;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SemaphoreTypeCreateInfo::SemaphoreTypeCreateInfo(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);
+    }
+}
+
+SemaphoreTypeCreateInfo::SemaphoreTypeCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO), pNext(nullptr), semaphoreType(), initialValue() {}
+
+SemaphoreTypeCreateInfo::SemaphoreTypeCreateInfo(const SemaphoreTypeCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    semaphoreType = copy_src.semaphoreType;
+    initialValue = copy_src.initialValue;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SemaphoreTypeCreateInfo& SemaphoreTypeCreateInfo::operator=(const SemaphoreTypeCreateInfo& 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;
+}
+
+SemaphoreTypeCreateInfo::~SemaphoreTypeCreateInfo() { FreePnextChain(pNext); }
+
+void SemaphoreTypeCreateInfo::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 SemaphoreTypeCreateInfo::initialize(const SemaphoreTypeCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphoreType = copy_src->semaphoreType;
+    initialValue = copy_src->initialValue;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+TimelineSemaphoreSubmitInfo::TimelineSemaphoreSubmitInfo(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);
+    }
+}
+
+TimelineSemaphoreSubmitInfo::TimelineSemaphoreSubmitInfo()
+    : sType(VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO),
+      pNext(nullptr),
+      waitSemaphoreValueCount(),
+      pWaitSemaphoreValues(nullptr),
+      signalSemaphoreValueCount(),
+      pSignalSemaphoreValues(nullptr) {}
+
+TimelineSemaphoreSubmitInfo::TimelineSemaphoreSubmitInfo(const TimelineSemaphoreSubmitInfo& 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);
+    }
+}
+
+TimelineSemaphoreSubmitInfo& TimelineSemaphoreSubmitInfo::operator=(const TimelineSemaphoreSubmitInfo& 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;
+}
+
+TimelineSemaphoreSubmitInfo::~TimelineSemaphoreSubmitInfo() {
+    if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues;
+    if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues;
+    FreePnextChain(pNext);
+}
+
+void TimelineSemaphoreSubmitInfo::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 TimelineSemaphoreSubmitInfo::initialize(const TimelineSemaphoreSubmitInfo* 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);
+    }
+}
+
+SemaphoreWaitInfo::SemaphoreWaitInfo(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);
+    }
+}
+
+SemaphoreWaitInfo::SemaphoreWaitInfo()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO),
+      pNext(nullptr),
+      flags(),
+      semaphoreCount(),
+      pSemaphores(nullptr),
+      pValues(nullptr) {}
+
+SemaphoreWaitInfo::SemaphoreWaitInfo(const SemaphoreWaitInfo& 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);
+    }
+}
+
+SemaphoreWaitInfo& SemaphoreWaitInfo::operator=(const SemaphoreWaitInfo& 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;
+}
+
+SemaphoreWaitInfo::~SemaphoreWaitInfo() {
+    if (pSemaphores) delete[] pSemaphores;
+    if (pValues) delete[] pValues;
+    FreePnextChain(pNext);
+}
+
+void SemaphoreWaitInfo::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 SemaphoreWaitInfo::initialize(const SemaphoreWaitInfo* 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);
+    }
+}
+
+SemaphoreSignalInfo::SemaphoreSignalInfo(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);
+    }
+}
+
+SemaphoreSignalInfo::SemaphoreSignalInfo() : sType(VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO), pNext(nullptr), semaphore(), value() {}
+
+SemaphoreSignalInfo::SemaphoreSignalInfo(const SemaphoreSignalInfo& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    value = copy_src.value;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SemaphoreSignalInfo& SemaphoreSignalInfo::operator=(const SemaphoreSignalInfo& 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;
+}
+
+SemaphoreSignalInfo::~SemaphoreSignalInfo() { FreePnextChain(pNext); }
+
+void SemaphoreSignalInfo::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 SemaphoreSignalInfo::initialize(const SemaphoreSignalInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    value = copy_src->value;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceBufferDeviceAddressFeatures::PhysicalDeviceBufferDeviceAddressFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceBufferDeviceAddressFeatures::PhysicalDeviceBufferDeviceAddressFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES),
+      pNext(nullptr),
+      bufferDeviceAddress(),
+      bufferDeviceAddressCaptureReplay(),
+      bufferDeviceAddressMultiDevice() {}
+
+PhysicalDeviceBufferDeviceAddressFeatures::PhysicalDeviceBufferDeviceAddressFeatures(
+    const PhysicalDeviceBufferDeviceAddressFeatures& copy_src) {
+    sType = copy_src.sType;
+    bufferDeviceAddress = copy_src.bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceBufferDeviceAddressFeatures& PhysicalDeviceBufferDeviceAddressFeatures::operator=(
+    const PhysicalDeviceBufferDeviceAddressFeatures& 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;
+}
+
+PhysicalDeviceBufferDeviceAddressFeatures::~PhysicalDeviceBufferDeviceAddressFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceBufferDeviceAddressFeatures::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 PhysicalDeviceBufferDeviceAddressFeatures::initialize(const PhysicalDeviceBufferDeviceAddressFeatures* 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);
+}
+
+BufferDeviceAddressInfo::BufferDeviceAddressInfo(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);
+    }
+}
+
+BufferDeviceAddressInfo::BufferDeviceAddressInfo()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO), pNext(nullptr), buffer() {}
+
+BufferDeviceAddressInfo::BufferDeviceAddressInfo(const BufferDeviceAddressInfo& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BufferDeviceAddressInfo& BufferDeviceAddressInfo::operator=(const BufferDeviceAddressInfo& 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;
+}
+
+BufferDeviceAddressInfo::~BufferDeviceAddressInfo() { FreePnextChain(pNext); }
+
+void BufferDeviceAddressInfo::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 BufferDeviceAddressInfo::initialize(const BufferDeviceAddressInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BufferOpaqueCaptureAddressCreateInfo::BufferOpaqueCaptureAddressCreateInfo(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);
+    }
+}
+
+BufferOpaqueCaptureAddressCreateInfo::BufferOpaqueCaptureAddressCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO), pNext(nullptr), opaqueCaptureAddress() {}
+
+BufferOpaqueCaptureAddressCreateInfo::BufferOpaqueCaptureAddressCreateInfo(const BufferOpaqueCaptureAddressCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    opaqueCaptureAddress = copy_src.opaqueCaptureAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BufferOpaqueCaptureAddressCreateInfo& BufferOpaqueCaptureAddressCreateInfo::operator=(
+    const BufferOpaqueCaptureAddressCreateInfo& 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;
+}
+
+BufferOpaqueCaptureAddressCreateInfo::~BufferOpaqueCaptureAddressCreateInfo() { FreePnextChain(pNext); }
+
+void BufferOpaqueCaptureAddressCreateInfo::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 BufferOpaqueCaptureAddressCreateInfo::initialize(const BufferOpaqueCaptureAddressCreateInfo* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    opaqueCaptureAddress = copy_src->opaqueCaptureAddress;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryOpaqueCaptureAddressAllocateInfo::MemoryOpaqueCaptureAddressAllocateInfo(
+    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);
+    }
+}
+
+MemoryOpaqueCaptureAddressAllocateInfo::MemoryOpaqueCaptureAddressAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO), pNext(nullptr), opaqueCaptureAddress() {}
+
+MemoryOpaqueCaptureAddressAllocateInfo::MemoryOpaqueCaptureAddressAllocateInfo(
+    const MemoryOpaqueCaptureAddressAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    opaqueCaptureAddress = copy_src.opaqueCaptureAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryOpaqueCaptureAddressAllocateInfo& MemoryOpaqueCaptureAddressAllocateInfo::operator=(
+    const MemoryOpaqueCaptureAddressAllocateInfo& 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;
+}
+
+MemoryOpaqueCaptureAddressAllocateInfo::~MemoryOpaqueCaptureAddressAllocateInfo() { FreePnextChain(pNext); }
+
+void MemoryOpaqueCaptureAddressAllocateInfo::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 MemoryOpaqueCaptureAddressAllocateInfo::initialize(const MemoryOpaqueCaptureAddressAllocateInfo* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    opaqueCaptureAddress = copy_src->opaqueCaptureAddress;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DeviceMemoryOpaqueCaptureAddressInfo::DeviceMemoryOpaqueCaptureAddressInfo(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);
+    }
+}
+
+DeviceMemoryOpaqueCaptureAddressInfo::DeviceMemoryOpaqueCaptureAddressInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO), pNext(nullptr), memory() {}
+
+DeviceMemoryOpaqueCaptureAddressInfo::DeviceMemoryOpaqueCaptureAddressInfo(const DeviceMemoryOpaqueCaptureAddressInfo& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceMemoryOpaqueCaptureAddressInfo& DeviceMemoryOpaqueCaptureAddressInfo::operator=(
+    const DeviceMemoryOpaqueCaptureAddressInfo& 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;
+}
+
+DeviceMemoryOpaqueCaptureAddressInfo::~DeviceMemoryOpaqueCaptureAddressInfo() { FreePnextChain(pNext); }
+
+void DeviceMemoryOpaqueCaptureAddressInfo::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 DeviceMemoryOpaqueCaptureAddressInfo::initialize(const DeviceMemoryOpaqueCaptureAddressInfo* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceVulkan13Features::PhysicalDeviceVulkan13Features(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);
+    }
+}
+
+PhysicalDeviceVulkan13Features::PhysicalDeviceVulkan13Features()
+    : 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() {}
+
+PhysicalDeviceVulkan13Features::PhysicalDeviceVulkan13Features(const PhysicalDeviceVulkan13Features& 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);
+}
+
+PhysicalDeviceVulkan13Features& PhysicalDeviceVulkan13Features::operator=(const PhysicalDeviceVulkan13Features& 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;
+}
+
+PhysicalDeviceVulkan13Features::~PhysicalDeviceVulkan13Features() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVulkan13Features::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 PhysicalDeviceVulkan13Features::initialize(const PhysicalDeviceVulkan13Features* 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);
+}
+
+PhysicalDeviceVulkan13Properties::PhysicalDeviceVulkan13Properties(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);
+    }
+}
+
+PhysicalDeviceVulkan13Properties::PhysicalDeviceVulkan13Properties()
+    : 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() {}
+
+PhysicalDeviceVulkan13Properties::PhysicalDeviceVulkan13Properties(const PhysicalDeviceVulkan13Properties& 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);
+}
+
+PhysicalDeviceVulkan13Properties& PhysicalDeviceVulkan13Properties::operator=(const PhysicalDeviceVulkan13Properties& 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;
+}
+
+PhysicalDeviceVulkan13Properties::~PhysicalDeviceVulkan13Properties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVulkan13Properties::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 PhysicalDeviceVulkan13Properties::initialize(const PhysicalDeviceVulkan13Properties* 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);
+}
+
+PipelineCreationFeedbackCreateInfo::PipelineCreationFeedbackCreateInfo(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);
+    }
+}
+
+PipelineCreationFeedbackCreateInfo::PipelineCreationFeedbackCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO),
+      pNext(nullptr),
+      pPipelineCreationFeedback(nullptr),
+      pipelineStageCreationFeedbackCount(),
+      pPipelineStageCreationFeedbacks(nullptr) {}
+
+PipelineCreationFeedbackCreateInfo::PipelineCreationFeedbackCreateInfo(const PipelineCreationFeedbackCreateInfo& 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);
+    }
+}
+
+PipelineCreationFeedbackCreateInfo& PipelineCreationFeedbackCreateInfo::operator=(
+    const PipelineCreationFeedbackCreateInfo& 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;
+}
+
+PipelineCreationFeedbackCreateInfo::~PipelineCreationFeedbackCreateInfo() {
+    if (pPipelineCreationFeedback) delete pPipelineCreationFeedback;
+    if (pPipelineStageCreationFeedbacks) delete[] pPipelineStageCreationFeedbacks;
+    FreePnextChain(pNext);
+}
+
+void PipelineCreationFeedbackCreateInfo::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 PipelineCreationFeedbackCreateInfo::initialize(const PipelineCreationFeedbackCreateInfo* 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);
+    }
+}
+
+PhysicalDeviceShaderTerminateInvocationFeatures::PhysicalDeviceShaderTerminateInvocationFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceShaderTerminateInvocationFeatures::PhysicalDeviceShaderTerminateInvocationFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES), pNext(nullptr), shaderTerminateInvocation() {}
+
+PhysicalDeviceShaderTerminateInvocationFeatures::PhysicalDeviceShaderTerminateInvocationFeatures(
+    const PhysicalDeviceShaderTerminateInvocationFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderTerminateInvocation = copy_src.shaderTerminateInvocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderTerminateInvocationFeatures& PhysicalDeviceShaderTerminateInvocationFeatures::operator=(
+    const PhysicalDeviceShaderTerminateInvocationFeatures& 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;
+}
+
+PhysicalDeviceShaderTerminateInvocationFeatures::~PhysicalDeviceShaderTerminateInvocationFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderTerminateInvocationFeatures::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 PhysicalDeviceShaderTerminateInvocationFeatures::initialize(const PhysicalDeviceShaderTerminateInvocationFeatures* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderTerminateInvocation = copy_src->shaderTerminateInvocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceToolProperties::PhysicalDeviceToolProperties(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];
+    }
+}
+
+PhysicalDeviceToolProperties::PhysicalDeviceToolProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES), pNext(nullptr), purposes() {}
+
+PhysicalDeviceToolProperties::PhysicalDeviceToolProperties(const PhysicalDeviceToolProperties& 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];
+    }
+}
+
+PhysicalDeviceToolProperties& PhysicalDeviceToolProperties::operator=(const PhysicalDeviceToolProperties& 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;
+}
+
+PhysicalDeviceToolProperties::~PhysicalDeviceToolProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceToolProperties::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 PhysicalDeviceToolProperties::initialize(const PhysicalDeviceToolProperties* 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];
+    }
+}
+
+PhysicalDeviceShaderDemoteToHelperInvocationFeatures::PhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceShaderDemoteToHelperInvocationFeatures::PhysicalDeviceShaderDemoteToHelperInvocationFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES),
+      pNext(nullptr),
+      shaderDemoteToHelperInvocation() {}
+
+PhysicalDeviceShaderDemoteToHelperInvocationFeatures::PhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    const PhysicalDeviceShaderDemoteToHelperInvocationFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderDemoteToHelperInvocation = copy_src.shaderDemoteToHelperInvocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderDemoteToHelperInvocationFeatures& PhysicalDeviceShaderDemoteToHelperInvocationFeatures::operator=(
+    const PhysicalDeviceShaderDemoteToHelperInvocationFeatures& 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;
+}
+
+PhysicalDeviceShaderDemoteToHelperInvocationFeatures::~PhysicalDeviceShaderDemoteToHelperInvocationFeatures() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceShaderDemoteToHelperInvocationFeatures::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 PhysicalDeviceShaderDemoteToHelperInvocationFeatures::initialize(
+    const PhysicalDeviceShaderDemoteToHelperInvocationFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderDemoteToHelperInvocation = copy_src->shaderDemoteToHelperInvocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePrivateDataFeatures::PhysicalDevicePrivateDataFeatures(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);
+    }
+}
+
+PhysicalDevicePrivateDataFeatures::PhysicalDevicePrivateDataFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES), pNext(nullptr), privateData() {}
+
+PhysicalDevicePrivateDataFeatures::PhysicalDevicePrivateDataFeatures(const PhysicalDevicePrivateDataFeatures& copy_src) {
+    sType = copy_src.sType;
+    privateData = copy_src.privateData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePrivateDataFeatures& PhysicalDevicePrivateDataFeatures::operator=(const PhysicalDevicePrivateDataFeatures& 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;
+}
+
+PhysicalDevicePrivateDataFeatures::~PhysicalDevicePrivateDataFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDevicePrivateDataFeatures::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 PhysicalDevicePrivateDataFeatures::initialize(const PhysicalDevicePrivateDataFeatures* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    privateData = copy_src->privateData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DevicePrivateDataCreateInfo::DevicePrivateDataCreateInfo(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);
+    }
+}
+
+DevicePrivateDataCreateInfo::DevicePrivateDataCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO), pNext(nullptr), privateDataSlotRequestCount() {}
+
+DevicePrivateDataCreateInfo::DevicePrivateDataCreateInfo(const DevicePrivateDataCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    privateDataSlotRequestCount = copy_src.privateDataSlotRequestCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DevicePrivateDataCreateInfo& DevicePrivateDataCreateInfo::operator=(const DevicePrivateDataCreateInfo& 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;
+}
+
+DevicePrivateDataCreateInfo::~DevicePrivateDataCreateInfo() { FreePnextChain(pNext); }
+
+void DevicePrivateDataCreateInfo::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 DevicePrivateDataCreateInfo::initialize(const DevicePrivateDataCreateInfo* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    privateDataSlotRequestCount = copy_src->privateDataSlotRequestCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PrivateDataSlotCreateInfo::PrivateDataSlotCreateInfo(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);
+    }
+}
+
+PrivateDataSlotCreateInfo::PrivateDataSlotCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO), pNext(nullptr), flags() {}
+
+PrivateDataSlotCreateInfo::PrivateDataSlotCreateInfo(const PrivateDataSlotCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PrivateDataSlotCreateInfo& PrivateDataSlotCreateInfo::operator=(const PrivateDataSlotCreateInfo& 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;
+}
+
+PrivateDataSlotCreateInfo::~PrivateDataSlotCreateInfo() { FreePnextChain(pNext); }
+
+void PrivateDataSlotCreateInfo::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 PrivateDataSlotCreateInfo::initialize(const PrivateDataSlotCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePipelineCreationCacheControlFeatures::PhysicalDevicePipelineCreationCacheControlFeatures(
+    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);
+    }
+}
+
+PhysicalDevicePipelineCreationCacheControlFeatures::PhysicalDevicePipelineCreationCacheControlFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES),
+      pNext(nullptr),
+      pipelineCreationCacheControl() {}
+
+PhysicalDevicePipelineCreationCacheControlFeatures::PhysicalDevicePipelineCreationCacheControlFeatures(
+    const PhysicalDevicePipelineCreationCacheControlFeatures& copy_src) {
+    sType = copy_src.sType;
+    pipelineCreationCacheControl = copy_src.pipelineCreationCacheControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePipelineCreationCacheControlFeatures& PhysicalDevicePipelineCreationCacheControlFeatures::operator=(
+    const PhysicalDevicePipelineCreationCacheControlFeatures& 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;
+}
+
+PhysicalDevicePipelineCreationCacheControlFeatures::~PhysicalDevicePipelineCreationCacheControlFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDevicePipelineCreationCacheControlFeatures::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 PhysicalDevicePipelineCreationCacheControlFeatures::initialize(
+    const PhysicalDevicePipelineCreationCacheControlFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineCreationCacheControl = copy_src->pipelineCreationCacheControl;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryBarrier2::MemoryBarrier2(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);
+    }
+}
+
+MemoryBarrier2::MemoryBarrier2()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER_2), pNext(nullptr), srcStageMask(), srcAccessMask(), dstStageMask(), dstAccessMask() {}
+
+MemoryBarrier2::MemoryBarrier2(const MemoryBarrier2& 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);
+}
+
+MemoryBarrier2& MemoryBarrier2::operator=(const MemoryBarrier2& 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;
+}
+
+MemoryBarrier2::~MemoryBarrier2() { FreePnextChain(pNext); }
+
+void MemoryBarrier2::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 MemoryBarrier2::initialize(const MemoryBarrier2* 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);
+}
+
+BufferMemoryBarrier2::BufferMemoryBarrier2(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);
+    }
+}
+
+BufferMemoryBarrier2::BufferMemoryBarrier2()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2),
+      pNext(nullptr),
+      srcStageMask(),
+      srcAccessMask(),
+      dstStageMask(),
+      dstAccessMask(),
+      srcQueueFamilyIndex(),
+      dstQueueFamilyIndex(),
+      buffer(),
+      offset(),
+      size() {}
+
+BufferMemoryBarrier2::BufferMemoryBarrier2(const BufferMemoryBarrier2& 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);
+}
+
+BufferMemoryBarrier2& BufferMemoryBarrier2::operator=(const BufferMemoryBarrier2& 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;
+}
+
+BufferMemoryBarrier2::~BufferMemoryBarrier2() { FreePnextChain(pNext); }
+
+void BufferMemoryBarrier2::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 BufferMemoryBarrier2::initialize(const BufferMemoryBarrier2* 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);
+}
+
+ImageMemoryBarrier2::ImageMemoryBarrier2(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);
+    }
+}
+
+ImageMemoryBarrier2::ImageMemoryBarrier2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2),
+      pNext(nullptr),
+      srcStageMask(),
+      srcAccessMask(),
+      dstStageMask(),
+      dstAccessMask(),
+      oldLayout(),
+      newLayout(),
+      srcQueueFamilyIndex(),
+      dstQueueFamilyIndex(),
+      image(),
+      subresourceRange() {}
+
+ImageMemoryBarrier2::ImageMemoryBarrier2(const ImageMemoryBarrier2& 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);
+}
+
+ImageMemoryBarrier2& ImageMemoryBarrier2::operator=(const ImageMemoryBarrier2& 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;
+}
+
+ImageMemoryBarrier2::~ImageMemoryBarrier2() { FreePnextChain(pNext); }
+
+void ImageMemoryBarrier2::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 ImageMemoryBarrier2::initialize(const ImageMemoryBarrier2* 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);
+}
+
+DependencyInfo::DependencyInfo(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 MemoryBarrier2[memoryBarrierCount];
+        for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
+            pMemoryBarriers[i].initialize(&in_struct->pMemoryBarriers[i]);
+        }
+    }
+    if (bufferMemoryBarrierCount && in_struct->pBufferMemoryBarriers) {
+        pBufferMemoryBarriers = new BufferMemoryBarrier2[bufferMemoryBarrierCount];
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            pBufferMemoryBarriers[i].initialize(&in_struct->pBufferMemoryBarriers[i]);
+        }
+    }
+    if (imageMemoryBarrierCount && in_struct->pImageMemoryBarriers) {
+        pImageMemoryBarriers = new ImageMemoryBarrier2[imageMemoryBarrierCount];
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            pImageMemoryBarriers[i].initialize(&in_struct->pImageMemoryBarriers[i]);
+        }
+    }
+}
+
+DependencyInfo::DependencyInfo()
+    : sType(VK_STRUCTURE_TYPE_DEPENDENCY_INFO),
+      pNext(nullptr),
+      dependencyFlags(),
+      memoryBarrierCount(),
+      pMemoryBarriers(nullptr),
+      bufferMemoryBarrierCount(),
+      pBufferMemoryBarriers(nullptr),
+      imageMemoryBarrierCount(),
+      pImageMemoryBarriers(nullptr) {}
+
+DependencyInfo::DependencyInfo(const DependencyInfo& 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 MemoryBarrier2[memoryBarrierCount];
+        for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
+            pMemoryBarriers[i].initialize(&copy_src.pMemoryBarriers[i]);
+        }
+    }
+    if (bufferMemoryBarrierCount && copy_src.pBufferMemoryBarriers) {
+        pBufferMemoryBarriers = new BufferMemoryBarrier2[bufferMemoryBarrierCount];
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            pBufferMemoryBarriers[i].initialize(&copy_src.pBufferMemoryBarriers[i]);
+        }
+    }
+    if (imageMemoryBarrierCount && copy_src.pImageMemoryBarriers) {
+        pImageMemoryBarriers = new ImageMemoryBarrier2[imageMemoryBarrierCount];
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            pImageMemoryBarriers[i].initialize(&copy_src.pImageMemoryBarriers[i]);
+        }
+    }
+}
+
+DependencyInfo& DependencyInfo::operator=(const DependencyInfo& 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 MemoryBarrier2[memoryBarrierCount];
+        for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
+            pMemoryBarriers[i].initialize(&copy_src.pMemoryBarriers[i]);
+        }
+    }
+    if (bufferMemoryBarrierCount && copy_src.pBufferMemoryBarriers) {
+        pBufferMemoryBarriers = new BufferMemoryBarrier2[bufferMemoryBarrierCount];
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            pBufferMemoryBarriers[i].initialize(&copy_src.pBufferMemoryBarriers[i]);
+        }
+    }
+    if (imageMemoryBarrierCount && copy_src.pImageMemoryBarriers) {
+        pImageMemoryBarriers = new ImageMemoryBarrier2[imageMemoryBarrierCount];
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            pImageMemoryBarriers[i].initialize(&copy_src.pImageMemoryBarriers[i]);
+        }
+    }
+
+    return *this;
+}
+
+DependencyInfo::~DependencyInfo() {
+    if (pMemoryBarriers) delete[] pMemoryBarriers;
+    if (pBufferMemoryBarriers) delete[] pBufferMemoryBarriers;
+    if (pImageMemoryBarriers) delete[] pImageMemoryBarriers;
+    FreePnextChain(pNext);
+}
+
+void DependencyInfo::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 MemoryBarrier2[memoryBarrierCount];
+        for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
+            pMemoryBarriers[i].initialize(&in_struct->pMemoryBarriers[i]);
+        }
+    }
+    if (bufferMemoryBarrierCount && in_struct->pBufferMemoryBarriers) {
+        pBufferMemoryBarriers = new BufferMemoryBarrier2[bufferMemoryBarrierCount];
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            pBufferMemoryBarriers[i].initialize(&in_struct->pBufferMemoryBarriers[i]);
+        }
+    }
+    if (imageMemoryBarrierCount && in_struct->pImageMemoryBarriers) {
+        pImageMemoryBarriers = new ImageMemoryBarrier2[imageMemoryBarrierCount];
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            pImageMemoryBarriers[i].initialize(&in_struct->pImageMemoryBarriers[i]);
+        }
+    }
+}
+
+void DependencyInfo::initialize(const DependencyInfo* 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 MemoryBarrier2[memoryBarrierCount];
+        for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
+            pMemoryBarriers[i].initialize(&copy_src->pMemoryBarriers[i]);
+        }
+    }
+    if (bufferMemoryBarrierCount && copy_src->pBufferMemoryBarriers) {
+        pBufferMemoryBarriers = new BufferMemoryBarrier2[bufferMemoryBarrierCount];
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            pBufferMemoryBarriers[i].initialize(&copy_src->pBufferMemoryBarriers[i]);
+        }
+    }
+    if (imageMemoryBarrierCount && copy_src->pImageMemoryBarriers) {
+        pImageMemoryBarriers = new ImageMemoryBarrier2[imageMemoryBarrierCount];
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            pImageMemoryBarriers[i].initialize(&copy_src->pImageMemoryBarriers[i]);
+        }
+    }
+}
+
+SemaphoreSubmitInfo::SemaphoreSubmitInfo(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);
+    }
+}
+
+SemaphoreSubmitInfo::SemaphoreSubmitInfo()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO), pNext(nullptr), semaphore(), value(), stageMask(), deviceIndex() {}
+
+SemaphoreSubmitInfo::SemaphoreSubmitInfo(const SemaphoreSubmitInfo& 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);
+}
+
+SemaphoreSubmitInfo& SemaphoreSubmitInfo::operator=(const SemaphoreSubmitInfo& 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;
+}
+
+SemaphoreSubmitInfo::~SemaphoreSubmitInfo() { FreePnextChain(pNext); }
+
+void SemaphoreSubmitInfo::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 SemaphoreSubmitInfo::initialize(const SemaphoreSubmitInfo* 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);
+}
+
+CommandBufferSubmitInfo::CommandBufferSubmitInfo(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);
+    }
+}
+
+CommandBufferSubmitInfo::CommandBufferSubmitInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO), pNext(nullptr), commandBuffer(), deviceMask() {}
+
+CommandBufferSubmitInfo::CommandBufferSubmitInfo(const CommandBufferSubmitInfo& copy_src) {
+    sType = copy_src.sType;
+    commandBuffer = copy_src.commandBuffer;
+    deviceMask = copy_src.deviceMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CommandBufferSubmitInfo& CommandBufferSubmitInfo::operator=(const CommandBufferSubmitInfo& 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;
+}
+
+CommandBufferSubmitInfo::~CommandBufferSubmitInfo() { FreePnextChain(pNext); }
+
+void CommandBufferSubmitInfo::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 CommandBufferSubmitInfo::initialize(const CommandBufferSubmitInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    commandBuffer = copy_src->commandBuffer;
+    deviceMask = copy_src->deviceMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SubmitInfo2::SubmitInfo2(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 SemaphoreSubmitInfo[waitSemaphoreInfoCount];
+        for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
+            pWaitSemaphoreInfos[i].initialize(&in_struct->pWaitSemaphoreInfos[i]);
+        }
+    }
+    if (commandBufferInfoCount && in_struct->pCommandBufferInfos) {
+        pCommandBufferInfos = new CommandBufferSubmitInfo[commandBufferInfoCount];
+        for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
+            pCommandBufferInfos[i].initialize(&in_struct->pCommandBufferInfos[i]);
+        }
+    }
+    if (signalSemaphoreInfoCount && in_struct->pSignalSemaphoreInfos) {
+        pSignalSemaphoreInfos = new SemaphoreSubmitInfo[signalSemaphoreInfoCount];
+        for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
+            pSignalSemaphoreInfos[i].initialize(&in_struct->pSignalSemaphoreInfos[i]);
+        }
+    }
+}
+
+SubmitInfo2::SubmitInfo2()
+    : sType(VK_STRUCTURE_TYPE_SUBMIT_INFO_2),
+      pNext(nullptr),
+      flags(),
+      waitSemaphoreInfoCount(),
+      pWaitSemaphoreInfos(nullptr),
+      commandBufferInfoCount(),
+      pCommandBufferInfos(nullptr),
+      signalSemaphoreInfoCount(),
+      pSignalSemaphoreInfos(nullptr) {}
+
+SubmitInfo2::SubmitInfo2(const SubmitInfo2& 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 SemaphoreSubmitInfo[waitSemaphoreInfoCount];
+        for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
+            pWaitSemaphoreInfos[i].initialize(&copy_src.pWaitSemaphoreInfos[i]);
+        }
+    }
+    if (commandBufferInfoCount && copy_src.pCommandBufferInfos) {
+        pCommandBufferInfos = new CommandBufferSubmitInfo[commandBufferInfoCount];
+        for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
+            pCommandBufferInfos[i].initialize(&copy_src.pCommandBufferInfos[i]);
+        }
+    }
+    if (signalSemaphoreInfoCount && copy_src.pSignalSemaphoreInfos) {
+        pSignalSemaphoreInfos = new SemaphoreSubmitInfo[signalSemaphoreInfoCount];
+        for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
+            pSignalSemaphoreInfos[i].initialize(&copy_src.pSignalSemaphoreInfos[i]);
+        }
+    }
+}
+
+SubmitInfo2& SubmitInfo2::operator=(const SubmitInfo2& 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 SemaphoreSubmitInfo[waitSemaphoreInfoCount];
+        for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
+            pWaitSemaphoreInfos[i].initialize(&copy_src.pWaitSemaphoreInfos[i]);
+        }
+    }
+    if (commandBufferInfoCount && copy_src.pCommandBufferInfos) {
+        pCommandBufferInfos = new CommandBufferSubmitInfo[commandBufferInfoCount];
+        for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
+            pCommandBufferInfos[i].initialize(&copy_src.pCommandBufferInfos[i]);
+        }
+    }
+    if (signalSemaphoreInfoCount && copy_src.pSignalSemaphoreInfos) {
+        pSignalSemaphoreInfos = new SemaphoreSubmitInfo[signalSemaphoreInfoCount];
+        for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
+            pSignalSemaphoreInfos[i].initialize(&copy_src.pSignalSemaphoreInfos[i]);
+        }
+    }
+
+    return *this;
+}
+
+SubmitInfo2::~SubmitInfo2() {
+    if (pWaitSemaphoreInfos) delete[] pWaitSemaphoreInfos;
+    if (pCommandBufferInfos) delete[] pCommandBufferInfos;
+    if (pSignalSemaphoreInfos) delete[] pSignalSemaphoreInfos;
+    FreePnextChain(pNext);
+}
+
+void SubmitInfo2::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 SemaphoreSubmitInfo[waitSemaphoreInfoCount];
+        for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
+            pWaitSemaphoreInfos[i].initialize(&in_struct->pWaitSemaphoreInfos[i]);
+        }
+    }
+    if (commandBufferInfoCount && in_struct->pCommandBufferInfos) {
+        pCommandBufferInfos = new CommandBufferSubmitInfo[commandBufferInfoCount];
+        for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
+            pCommandBufferInfos[i].initialize(&in_struct->pCommandBufferInfos[i]);
+        }
+    }
+    if (signalSemaphoreInfoCount && in_struct->pSignalSemaphoreInfos) {
+        pSignalSemaphoreInfos = new SemaphoreSubmitInfo[signalSemaphoreInfoCount];
+        for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
+            pSignalSemaphoreInfos[i].initialize(&in_struct->pSignalSemaphoreInfos[i]);
+        }
+    }
+}
+
+void SubmitInfo2::initialize(const SubmitInfo2* 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 SemaphoreSubmitInfo[waitSemaphoreInfoCount];
+        for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
+            pWaitSemaphoreInfos[i].initialize(&copy_src->pWaitSemaphoreInfos[i]);
+        }
+    }
+    if (commandBufferInfoCount && copy_src->pCommandBufferInfos) {
+        pCommandBufferInfos = new CommandBufferSubmitInfo[commandBufferInfoCount];
+        for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
+            pCommandBufferInfos[i].initialize(&copy_src->pCommandBufferInfos[i]);
+        }
+    }
+    if (signalSemaphoreInfoCount && copy_src->pSignalSemaphoreInfos) {
+        pSignalSemaphoreInfos = new SemaphoreSubmitInfo[signalSemaphoreInfoCount];
+        for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
+            pSignalSemaphoreInfos[i].initialize(&copy_src->pSignalSemaphoreInfos[i]);
+        }
+    }
+}
+
+PhysicalDeviceSynchronization2Features::PhysicalDeviceSynchronization2Features(
+    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);
+    }
+}
+
+PhysicalDeviceSynchronization2Features::PhysicalDeviceSynchronization2Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES), pNext(nullptr), synchronization2() {}
+
+PhysicalDeviceSynchronization2Features::PhysicalDeviceSynchronization2Features(
+    const PhysicalDeviceSynchronization2Features& copy_src) {
+    sType = copy_src.sType;
+    synchronization2 = copy_src.synchronization2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSynchronization2Features& PhysicalDeviceSynchronization2Features::operator=(
+    const PhysicalDeviceSynchronization2Features& 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;
+}
+
+PhysicalDeviceSynchronization2Features::~PhysicalDeviceSynchronization2Features() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSynchronization2Features::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 PhysicalDeviceSynchronization2Features::initialize(const PhysicalDeviceSynchronization2Features* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    synchronization2 = copy_src->synchronization2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES),
+      pNext(nullptr),
+      shaderZeroInitializeWorkgroupMemory() {}
+
+PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    const PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderZeroInitializeWorkgroupMemory = copy_src.shaderZeroInitializeWorkgroupMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::operator=(
+    const PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& 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;
+}
+
+PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::~PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::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 PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::initialize(
+    const PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderZeroInitializeWorkgroupMemory = copy_src->shaderZeroInitializeWorkgroupMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceImageRobustnessFeatures::PhysicalDeviceImageRobustnessFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceImageRobustnessFeatures::PhysicalDeviceImageRobustnessFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES), pNext(nullptr), robustImageAccess() {}
+
+PhysicalDeviceImageRobustnessFeatures::PhysicalDeviceImageRobustnessFeatures(
+    const PhysicalDeviceImageRobustnessFeatures& copy_src) {
+    sType = copy_src.sType;
+    robustImageAccess = copy_src.robustImageAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceImageRobustnessFeatures& PhysicalDeviceImageRobustnessFeatures::operator=(
+    const PhysicalDeviceImageRobustnessFeatures& 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;
+}
+
+PhysicalDeviceImageRobustnessFeatures::~PhysicalDeviceImageRobustnessFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImageRobustnessFeatures::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 PhysicalDeviceImageRobustnessFeatures::initialize(const PhysicalDeviceImageRobustnessFeatures* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    robustImageAccess = copy_src->robustImageAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BufferCopy2::BufferCopy2(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);
+    }
+}
+
+BufferCopy2::BufferCopy2() : sType(VK_STRUCTURE_TYPE_BUFFER_COPY_2), pNext(nullptr), srcOffset(), dstOffset(), size() {}
+
+BufferCopy2::BufferCopy2(const BufferCopy2& copy_src) {
+    sType = copy_src.sType;
+    srcOffset = copy_src.srcOffset;
+    dstOffset = copy_src.dstOffset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BufferCopy2& BufferCopy2::operator=(const BufferCopy2& 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;
+}
+
+BufferCopy2::~BufferCopy2() { FreePnextChain(pNext); }
+
+void BufferCopy2::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 BufferCopy2::initialize(const BufferCopy2* 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);
+}
+
+CopyBufferInfo2::CopyBufferInfo2(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 BufferCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+CopyBufferInfo2::CopyBufferInfo2()
+    : sType(VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2), pNext(nullptr), srcBuffer(), dstBuffer(), regionCount(), pRegions(nullptr) {}
+
+CopyBufferInfo2::CopyBufferInfo2(const CopyBufferInfo2& 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 BufferCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+CopyBufferInfo2& CopyBufferInfo2::operator=(const CopyBufferInfo2& 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 BufferCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+CopyBufferInfo2::~CopyBufferInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void CopyBufferInfo2::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 BufferCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void CopyBufferInfo2::initialize(const CopyBufferInfo2* 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 BufferCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+ImageCopy2::ImageCopy2(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);
+    }
+}
+
+ImageCopy2::ImageCopy2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_COPY_2),
+      pNext(nullptr),
+      srcSubresource(),
+      srcOffset(),
+      dstSubresource(),
+      dstOffset(),
+      extent() {}
+
+ImageCopy2::ImageCopy2(const ImageCopy2& 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);
+}
+
+ImageCopy2& ImageCopy2::operator=(const ImageCopy2& 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;
+}
+
+ImageCopy2::~ImageCopy2() { FreePnextChain(pNext); }
+
+void ImageCopy2::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 ImageCopy2::initialize(const ImageCopy2* 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);
+}
+
+CopyImageInfo2::CopyImageInfo2(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 ImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+CopyImageInfo2::CopyImageInfo2()
+    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2),
+      pNext(nullptr),
+      srcImage(),
+      srcImageLayout(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+CopyImageInfo2::CopyImageInfo2(const CopyImageInfo2& 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 ImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+CopyImageInfo2& CopyImageInfo2::operator=(const CopyImageInfo2& 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 ImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+CopyImageInfo2::~CopyImageInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void CopyImageInfo2::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 ImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void CopyImageInfo2::initialize(const CopyImageInfo2* 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 ImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+BufferImageCopy2::BufferImageCopy2(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);
+    }
+}
+
+BufferImageCopy2::BufferImageCopy2()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2),
+      pNext(nullptr),
+      bufferOffset(),
+      bufferRowLength(),
+      bufferImageHeight(),
+      imageSubresource(),
+      imageOffset(),
+      imageExtent() {}
+
+BufferImageCopy2::BufferImageCopy2(const BufferImageCopy2& 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);
+}
+
+BufferImageCopy2& BufferImageCopy2::operator=(const BufferImageCopy2& 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;
+}
+
+BufferImageCopy2::~BufferImageCopy2() { FreePnextChain(pNext); }
+
+void BufferImageCopy2::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 BufferImageCopy2::initialize(const BufferImageCopy2* 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);
+}
+
+CopyBufferToImageInfo2::CopyBufferToImageInfo2(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 BufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+CopyBufferToImageInfo2::CopyBufferToImageInfo2()
+    : sType(VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2),
+      pNext(nullptr),
+      srcBuffer(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+CopyBufferToImageInfo2::CopyBufferToImageInfo2(const CopyBufferToImageInfo2& 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 BufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+CopyBufferToImageInfo2& CopyBufferToImageInfo2::operator=(const CopyBufferToImageInfo2& 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 BufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+CopyBufferToImageInfo2::~CopyBufferToImageInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void CopyBufferToImageInfo2::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 BufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void CopyBufferToImageInfo2::initialize(const CopyBufferToImageInfo2* 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 BufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+CopyImageToBufferInfo2::CopyImageToBufferInfo2(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 BufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+CopyImageToBufferInfo2::CopyImageToBufferInfo2()
+    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2),
+      pNext(nullptr),
+      srcImage(),
+      srcImageLayout(),
+      dstBuffer(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+CopyImageToBufferInfo2::CopyImageToBufferInfo2(const CopyImageToBufferInfo2& 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 BufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+CopyImageToBufferInfo2& CopyImageToBufferInfo2::operator=(const CopyImageToBufferInfo2& 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 BufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+CopyImageToBufferInfo2::~CopyImageToBufferInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void CopyImageToBufferInfo2::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 BufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void CopyImageToBufferInfo2::initialize(const CopyImageToBufferInfo2* 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 BufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+ImageBlit2::ImageBlit2(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];
+    }
+}
+
+ImageBlit2::ImageBlit2() : sType(VK_STRUCTURE_TYPE_IMAGE_BLIT_2), pNext(nullptr), srcSubresource(), dstSubresource() {}
+
+ImageBlit2::ImageBlit2(const ImageBlit2& 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];
+    }
+}
+
+ImageBlit2& ImageBlit2::operator=(const ImageBlit2& 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;
+}
+
+ImageBlit2::~ImageBlit2() { FreePnextChain(pNext); }
+
+void ImageBlit2::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 ImageBlit2::initialize(const ImageBlit2* 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];
+    }
+}
+
+BlitImageInfo2::BlitImageInfo2(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 ImageBlit2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+BlitImageInfo2::BlitImageInfo2()
+    : sType(VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2),
+      pNext(nullptr),
+      srcImage(),
+      srcImageLayout(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr),
+      filter() {}
+
+BlitImageInfo2::BlitImageInfo2(const BlitImageInfo2& 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 ImageBlit2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+BlitImageInfo2& BlitImageInfo2::operator=(const BlitImageInfo2& 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 ImageBlit2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+BlitImageInfo2::~BlitImageInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void BlitImageInfo2::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 ImageBlit2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void BlitImageInfo2::initialize(const BlitImageInfo2* 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 ImageBlit2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+ImageResolve2::ImageResolve2(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);
+    }
+}
+
+ImageResolve2::ImageResolve2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2),
+      pNext(nullptr),
+      srcSubresource(),
+      srcOffset(),
+      dstSubresource(),
+      dstOffset(),
+      extent() {}
+
+ImageResolve2::ImageResolve2(const ImageResolve2& 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);
+}
+
+ImageResolve2& ImageResolve2::operator=(const ImageResolve2& 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;
+}
+
+ImageResolve2::~ImageResolve2() { FreePnextChain(pNext); }
+
+void ImageResolve2::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 ImageResolve2::initialize(const ImageResolve2* 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);
+}
+
+ResolveImageInfo2::ResolveImageInfo2(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 ImageResolve2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+ResolveImageInfo2::ResolveImageInfo2()
+    : sType(VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2),
+      pNext(nullptr),
+      srcImage(),
+      srcImageLayout(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+ResolveImageInfo2::ResolveImageInfo2(const ResolveImageInfo2& 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 ImageResolve2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+ResolveImageInfo2& ResolveImageInfo2::operator=(const ResolveImageInfo2& 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 ImageResolve2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+ResolveImageInfo2::~ResolveImageInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void ResolveImageInfo2::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 ImageResolve2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void ResolveImageInfo2::initialize(const ResolveImageInfo2* 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 ImageResolve2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+PhysicalDeviceSubgroupSizeControlFeatures::PhysicalDeviceSubgroupSizeControlFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceSubgroupSizeControlFeatures::PhysicalDeviceSubgroupSizeControlFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES),
+      pNext(nullptr),
+      subgroupSizeControl(),
+      computeFullSubgroups() {}
+
+PhysicalDeviceSubgroupSizeControlFeatures::PhysicalDeviceSubgroupSizeControlFeatures(
+    const PhysicalDeviceSubgroupSizeControlFeatures& copy_src) {
+    sType = copy_src.sType;
+    subgroupSizeControl = copy_src.subgroupSizeControl;
+    computeFullSubgroups = copy_src.computeFullSubgroups;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSubgroupSizeControlFeatures& PhysicalDeviceSubgroupSizeControlFeatures::operator=(
+    const PhysicalDeviceSubgroupSizeControlFeatures& 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;
+}
+
+PhysicalDeviceSubgroupSizeControlFeatures::~PhysicalDeviceSubgroupSizeControlFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSubgroupSizeControlFeatures::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 PhysicalDeviceSubgroupSizeControlFeatures::initialize(const PhysicalDeviceSubgroupSizeControlFeatures* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subgroupSizeControl = copy_src->subgroupSizeControl;
+    computeFullSubgroups = copy_src->computeFullSubgroups;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceSubgroupSizeControlProperties::PhysicalDeviceSubgroupSizeControlProperties(
+    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);
+    }
+}
+
+PhysicalDeviceSubgroupSizeControlProperties::PhysicalDeviceSubgroupSizeControlProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES),
+      pNext(nullptr),
+      minSubgroupSize(),
+      maxSubgroupSize(),
+      maxComputeWorkgroupSubgroups(),
+      requiredSubgroupSizeStages() {}
+
+PhysicalDeviceSubgroupSizeControlProperties::PhysicalDeviceSubgroupSizeControlProperties(
+    const PhysicalDeviceSubgroupSizeControlProperties& 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);
+}
+
+PhysicalDeviceSubgroupSizeControlProperties& PhysicalDeviceSubgroupSizeControlProperties::operator=(
+    const PhysicalDeviceSubgroupSizeControlProperties& 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;
+}
+
+PhysicalDeviceSubgroupSizeControlProperties::~PhysicalDeviceSubgroupSizeControlProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSubgroupSizeControlProperties::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 PhysicalDeviceSubgroupSizeControlProperties::initialize(const PhysicalDeviceSubgroupSizeControlProperties* 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);
+}
+
+PipelineShaderStageRequiredSubgroupSizeCreateInfo::PipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    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);
+    }
+}
+
+PipelineShaderStageRequiredSubgroupSizeCreateInfo::PipelineShaderStageRequiredSubgroupSizeCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO), pNext(nullptr), requiredSubgroupSize() {}
+
+PipelineShaderStageRequiredSubgroupSizeCreateInfo::PipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    const PipelineShaderStageRequiredSubgroupSizeCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    requiredSubgroupSize = copy_src.requiredSubgroupSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineShaderStageRequiredSubgroupSizeCreateInfo& PipelineShaderStageRequiredSubgroupSizeCreateInfo::operator=(
+    const PipelineShaderStageRequiredSubgroupSizeCreateInfo& 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;
+}
+
+PipelineShaderStageRequiredSubgroupSizeCreateInfo::~PipelineShaderStageRequiredSubgroupSizeCreateInfo() { FreePnextChain(pNext); }
+
+void PipelineShaderStageRequiredSubgroupSizeCreateInfo::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 PipelineShaderStageRequiredSubgroupSizeCreateInfo::initialize(
+    const PipelineShaderStageRequiredSubgroupSizeCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    requiredSubgroupSize = copy_src->requiredSubgroupSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceInlineUniformBlockFeatures::PhysicalDeviceInlineUniformBlockFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceInlineUniformBlockFeatures::PhysicalDeviceInlineUniformBlockFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES),
+      pNext(nullptr),
+      inlineUniformBlock(),
+      descriptorBindingInlineUniformBlockUpdateAfterBind() {}
+
+PhysicalDeviceInlineUniformBlockFeatures::PhysicalDeviceInlineUniformBlockFeatures(
+    const PhysicalDeviceInlineUniformBlockFeatures& copy_src) {
+    sType = copy_src.sType;
+    inlineUniformBlock = copy_src.inlineUniformBlock;
+    descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src.descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceInlineUniformBlockFeatures& PhysicalDeviceInlineUniformBlockFeatures::operator=(
+    const PhysicalDeviceInlineUniformBlockFeatures& 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;
+}
+
+PhysicalDeviceInlineUniformBlockFeatures::~PhysicalDeviceInlineUniformBlockFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceInlineUniformBlockFeatures::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 PhysicalDeviceInlineUniformBlockFeatures::initialize(const PhysicalDeviceInlineUniformBlockFeatures* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    inlineUniformBlock = copy_src->inlineUniformBlock;
+    descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src->descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceInlineUniformBlockProperties::PhysicalDeviceInlineUniformBlockProperties(
+    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);
+    }
+}
+
+PhysicalDeviceInlineUniformBlockProperties::PhysicalDeviceInlineUniformBlockProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES),
+      pNext(nullptr),
+      maxInlineUniformBlockSize(),
+      maxPerStageDescriptorInlineUniformBlocks(),
+      maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks(),
+      maxDescriptorSetInlineUniformBlocks(),
+      maxDescriptorSetUpdateAfterBindInlineUniformBlocks() {}
+
+PhysicalDeviceInlineUniformBlockProperties::PhysicalDeviceInlineUniformBlockProperties(
+    const PhysicalDeviceInlineUniformBlockProperties& 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);
+}
+
+PhysicalDeviceInlineUniformBlockProperties& PhysicalDeviceInlineUniformBlockProperties::operator=(
+    const PhysicalDeviceInlineUniformBlockProperties& 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;
+}
+
+PhysicalDeviceInlineUniformBlockProperties::~PhysicalDeviceInlineUniformBlockProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceInlineUniformBlockProperties::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 PhysicalDeviceInlineUniformBlockProperties::initialize(const PhysicalDeviceInlineUniformBlockProperties* 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);
+}
+
+WriteDescriptorSetInlineUniformBlock::WriteDescriptorSetInlineUniformBlock(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;
+    }
+}
+
+WriteDescriptorSetInlineUniformBlock::WriteDescriptorSetInlineUniformBlock()
+    : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK), pNext(nullptr), dataSize(), pData(nullptr) {}
+
+WriteDescriptorSetInlineUniformBlock::WriteDescriptorSetInlineUniformBlock(const WriteDescriptorSetInlineUniformBlock& 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;
+    }
+}
+
+WriteDescriptorSetInlineUniformBlock& WriteDescriptorSetInlineUniformBlock::operator=(
+    const WriteDescriptorSetInlineUniformBlock& 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;
+}
+
+WriteDescriptorSetInlineUniformBlock::~WriteDescriptorSetInlineUniformBlock() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+}
+
+void WriteDescriptorSetInlineUniformBlock::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 WriteDescriptorSetInlineUniformBlock::initialize(const WriteDescriptorSetInlineUniformBlock* 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;
+    }
+}
+
+DescriptorPoolInlineUniformBlockCreateInfo::DescriptorPoolInlineUniformBlockCreateInfo(
+    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);
+    }
+}
+
+DescriptorPoolInlineUniformBlockCreateInfo::DescriptorPoolInlineUniformBlockCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO), pNext(nullptr), maxInlineUniformBlockBindings() {}
+
+DescriptorPoolInlineUniformBlockCreateInfo::DescriptorPoolInlineUniformBlockCreateInfo(
+    const DescriptorPoolInlineUniformBlockCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    maxInlineUniformBlockBindings = copy_src.maxInlineUniformBlockBindings;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DescriptorPoolInlineUniformBlockCreateInfo& DescriptorPoolInlineUniformBlockCreateInfo::operator=(
+    const DescriptorPoolInlineUniformBlockCreateInfo& 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;
+}
+
+DescriptorPoolInlineUniformBlockCreateInfo::~DescriptorPoolInlineUniformBlockCreateInfo() { FreePnextChain(pNext); }
+
+void DescriptorPoolInlineUniformBlockCreateInfo::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 DescriptorPoolInlineUniformBlockCreateInfo::initialize(const DescriptorPoolInlineUniformBlockCreateInfo* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxInlineUniformBlockBindings = copy_src->maxInlineUniformBlockBindings;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceTextureCompressionASTCHDRFeatures::PhysicalDeviceTextureCompressionASTCHDRFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceTextureCompressionASTCHDRFeatures::PhysicalDeviceTextureCompressionASTCHDRFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES),
+      pNext(nullptr),
+      textureCompressionASTC_HDR() {}
+
+PhysicalDeviceTextureCompressionASTCHDRFeatures::PhysicalDeviceTextureCompressionASTCHDRFeatures(
+    const PhysicalDeviceTextureCompressionASTCHDRFeatures& copy_src) {
+    sType = copy_src.sType;
+    textureCompressionASTC_HDR = copy_src.textureCompressionASTC_HDR;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceTextureCompressionASTCHDRFeatures& PhysicalDeviceTextureCompressionASTCHDRFeatures::operator=(
+    const PhysicalDeviceTextureCompressionASTCHDRFeatures& 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;
+}
+
+PhysicalDeviceTextureCompressionASTCHDRFeatures::~PhysicalDeviceTextureCompressionASTCHDRFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceTextureCompressionASTCHDRFeatures::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 PhysicalDeviceTextureCompressionASTCHDRFeatures::initialize(const PhysicalDeviceTextureCompressionASTCHDRFeatures* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    textureCompressionASTC_HDR = copy_src->textureCompressionASTC_HDR;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+RenderingAttachmentInfo::RenderingAttachmentInfo(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);
+    }
+}
+
+RenderingAttachmentInfo::RenderingAttachmentInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO),
+      pNext(nullptr),
+      imageView(),
+      imageLayout(),
+      resolveMode(),
+      resolveImageView(),
+      resolveImageLayout(),
+      loadOp(),
+      storeOp(),
+      clearValue() {}
+
+RenderingAttachmentInfo::RenderingAttachmentInfo(const RenderingAttachmentInfo& 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);
+}
+
+RenderingAttachmentInfo& RenderingAttachmentInfo::operator=(const RenderingAttachmentInfo& 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;
+}
+
+RenderingAttachmentInfo::~RenderingAttachmentInfo() { FreePnextChain(pNext); }
+
+void RenderingAttachmentInfo::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 RenderingAttachmentInfo::initialize(const RenderingAttachmentInfo* 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);
+}
+
+RenderingInfo::RenderingInfo(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 RenderingAttachmentInfo[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
+        }
+    }
+    if (in_struct->pDepthAttachment) pDepthAttachment = new RenderingAttachmentInfo(in_struct->pDepthAttachment);
+    if (in_struct->pStencilAttachment) pStencilAttachment = new RenderingAttachmentInfo(in_struct->pStencilAttachment);
+}
+
+RenderingInfo::RenderingInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_INFO),
+      pNext(nullptr),
+      flags(),
+      renderArea(),
+      layerCount(),
+      viewMask(),
+      colorAttachmentCount(),
+      pColorAttachments(nullptr),
+      pDepthAttachment(nullptr),
+      pStencilAttachment(nullptr) {}
+
+RenderingInfo::RenderingInfo(const RenderingInfo& 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 RenderingAttachmentInfo[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src.pColorAttachments[i]);
+        }
+    }
+    if (copy_src.pDepthAttachment) pDepthAttachment = new RenderingAttachmentInfo(*copy_src.pDepthAttachment);
+    if (copy_src.pStencilAttachment) pStencilAttachment = new RenderingAttachmentInfo(*copy_src.pStencilAttachment);
+}
+
+RenderingInfo& RenderingInfo::operator=(const RenderingInfo& 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 RenderingAttachmentInfo[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src.pColorAttachments[i]);
+        }
+    }
+    if (copy_src.pDepthAttachment) pDepthAttachment = new RenderingAttachmentInfo(*copy_src.pDepthAttachment);
+    if (copy_src.pStencilAttachment) pStencilAttachment = new RenderingAttachmentInfo(*copy_src.pStencilAttachment);
+
+    return *this;
+}
+
+RenderingInfo::~RenderingInfo() {
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pDepthAttachment) delete pDepthAttachment;
+    if (pStencilAttachment) delete pStencilAttachment;
+    FreePnextChain(pNext);
+}
+
+void RenderingInfo::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 RenderingAttachmentInfo[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
+        }
+    }
+    if (in_struct->pDepthAttachment) pDepthAttachment = new RenderingAttachmentInfo(in_struct->pDepthAttachment);
+    if (in_struct->pStencilAttachment) pStencilAttachment = new RenderingAttachmentInfo(in_struct->pStencilAttachment);
+}
+
+void RenderingInfo::initialize(const RenderingInfo* 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 RenderingAttachmentInfo[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src->pColorAttachments[i]);
+        }
+    }
+    if (copy_src->pDepthAttachment) pDepthAttachment = new RenderingAttachmentInfo(*copy_src->pDepthAttachment);
+    if (copy_src->pStencilAttachment) pStencilAttachment = new RenderingAttachmentInfo(*copy_src->pStencilAttachment);
+}
+
+PipelineRenderingCreateInfo::PipelineRenderingCreateInfo(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);
+        }
+    }
+}
+
+PipelineRenderingCreateInfo::PipelineRenderingCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO),
+      pNext(nullptr),
+      viewMask(),
+      colorAttachmentCount(),
+      pColorAttachmentFormats(nullptr),
+      depthAttachmentFormat(),
+      stencilAttachmentFormat() {}
+
+PipelineRenderingCreateInfo::PipelineRenderingCreateInfo(const PipelineRenderingCreateInfo& 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);
+    }
+}
+
+PipelineRenderingCreateInfo& PipelineRenderingCreateInfo::operator=(const PipelineRenderingCreateInfo& 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;
+}
+
+PipelineRenderingCreateInfo::~PipelineRenderingCreateInfo() {
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+}
+
+void PipelineRenderingCreateInfo::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 PipelineRenderingCreateInfo::initialize(const PipelineRenderingCreateInfo* 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);
+    }
+}
+
+PhysicalDeviceDynamicRenderingFeatures::PhysicalDeviceDynamicRenderingFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceDynamicRenderingFeatures::PhysicalDeviceDynamicRenderingFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES), pNext(nullptr), dynamicRendering() {}
+
+PhysicalDeviceDynamicRenderingFeatures::PhysicalDeviceDynamicRenderingFeatures(
+    const PhysicalDeviceDynamicRenderingFeatures& copy_src) {
+    sType = copy_src.sType;
+    dynamicRendering = copy_src.dynamicRendering;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDynamicRenderingFeatures& PhysicalDeviceDynamicRenderingFeatures::operator=(
+    const PhysicalDeviceDynamicRenderingFeatures& 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;
+}
+
+PhysicalDeviceDynamicRenderingFeatures::~PhysicalDeviceDynamicRenderingFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDynamicRenderingFeatures::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 PhysicalDeviceDynamicRenderingFeatures::initialize(const PhysicalDeviceDynamicRenderingFeatures* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dynamicRendering = copy_src->dynamicRendering;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CommandBufferInheritanceRenderingInfo::CommandBufferInheritanceRenderingInfo(
+    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);
+    }
+}
+
+CommandBufferInheritanceRenderingInfo::CommandBufferInheritanceRenderingInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO),
+      pNext(nullptr),
+      flags(),
+      viewMask(),
+      colorAttachmentCount(),
+      pColorAttachmentFormats(nullptr),
+      depthAttachmentFormat(),
+      stencilAttachmentFormat(),
+      rasterizationSamples() {}
+
+CommandBufferInheritanceRenderingInfo::CommandBufferInheritanceRenderingInfo(
+    const CommandBufferInheritanceRenderingInfo& 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);
+    }
+}
+
+CommandBufferInheritanceRenderingInfo& CommandBufferInheritanceRenderingInfo::operator=(
+    const CommandBufferInheritanceRenderingInfo& 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;
+}
+
+CommandBufferInheritanceRenderingInfo::~CommandBufferInheritanceRenderingInfo() {
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+}
+
+void CommandBufferInheritanceRenderingInfo::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 CommandBufferInheritanceRenderingInfo::initialize(const CommandBufferInheritanceRenderingInfo* 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);
+    }
+}
+
+PhysicalDeviceShaderIntegerDotProductFeatures::PhysicalDeviceShaderIntegerDotProductFeatures(
+    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);
+    }
+}
+
+PhysicalDeviceShaderIntegerDotProductFeatures::PhysicalDeviceShaderIntegerDotProductFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES), pNext(nullptr), shaderIntegerDotProduct() {}
+
+PhysicalDeviceShaderIntegerDotProductFeatures::PhysicalDeviceShaderIntegerDotProductFeatures(
+    const PhysicalDeviceShaderIntegerDotProductFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderIntegerDotProduct = copy_src.shaderIntegerDotProduct;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderIntegerDotProductFeatures& PhysicalDeviceShaderIntegerDotProductFeatures::operator=(
+    const PhysicalDeviceShaderIntegerDotProductFeatures& 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;
+}
+
+PhysicalDeviceShaderIntegerDotProductFeatures::~PhysicalDeviceShaderIntegerDotProductFeatures() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderIntegerDotProductFeatures::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 PhysicalDeviceShaderIntegerDotProductFeatures::initialize(const PhysicalDeviceShaderIntegerDotProductFeatures* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderIntegerDotProduct = copy_src->shaderIntegerDotProduct;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderIntegerDotProductProperties::PhysicalDeviceShaderIntegerDotProductProperties(
+    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);
+    }
+}
+
+PhysicalDeviceShaderIntegerDotProductProperties::PhysicalDeviceShaderIntegerDotProductProperties()
+    : 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() {}
+
+PhysicalDeviceShaderIntegerDotProductProperties::PhysicalDeviceShaderIntegerDotProductProperties(
+    const PhysicalDeviceShaderIntegerDotProductProperties& 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);
+}
+
+PhysicalDeviceShaderIntegerDotProductProperties& PhysicalDeviceShaderIntegerDotProductProperties::operator=(
+    const PhysicalDeviceShaderIntegerDotProductProperties& 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;
+}
+
+PhysicalDeviceShaderIntegerDotProductProperties::~PhysicalDeviceShaderIntegerDotProductProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderIntegerDotProductProperties::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 PhysicalDeviceShaderIntegerDotProductProperties::initialize(const PhysicalDeviceShaderIntegerDotProductProperties* 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);
+}
+
+PhysicalDeviceTexelBufferAlignmentProperties::PhysicalDeviceTexelBufferAlignmentProperties(
+    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);
+    }
+}
+
+PhysicalDeviceTexelBufferAlignmentProperties::PhysicalDeviceTexelBufferAlignmentProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES),
+      pNext(nullptr),
+      storageTexelBufferOffsetAlignmentBytes(),
+      storageTexelBufferOffsetSingleTexelAlignment(),
+      uniformTexelBufferOffsetAlignmentBytes(),
+      uniformTexelBufferOffsetSingleTexelAlignment() {}
+
+PhysicalDeviceTexelBufferAlignmentProperties::PhysicalDeviceTexelBufferAlignmentProperties(
+    const PhysicalDeviceTexelBufferAlignmentProperties& 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);
+}
+
+PhysicalDeviceTexelBufferAlignmentProperties& PhysicalDeviceTexelBufferAlignmentProperties::operator=(
+    const PhysicalDeviceTexelBufferAlignmentProperties& 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;
+}
+
+PhysicalDeviceTexelBufferAlignmentProperties::~PhysicalDeviceTexelBufferAlignmentProperties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceTexelBufferAlignmentProperties::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 PhysicalDeviceTexelBufferAlignmentProperties::initialize(const PhysicalDeviceTexelBufferAlignmentProperties* 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);
+}
+
+FormatProperties3::FormatProperties3(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);
+    }
+}
+
+FormatProperties3::FormatProperties3()
+    : sType(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3),
+      pNext(nullptr),
+      linearTilingFeatures(),
+      optimalTilingFeatures(),
+      bufferFeatures() {}
+
+FormatProperties3::FormatProperties3(const FormatProperties3& copy_src) {
+    sType = copy_src.sType;
+    linearTilingFeatures = copy_src.linearTilingFeatures;
+    optimalTilingFeatures = copy_src.optimalTilingFeatures;
+    bufferFeatures = copy_src.bufferFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+FormatProperties3& FormatProperties3::operator=(const FormatProperties3& 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;
+}
+
+FormatProperties3::~FormatProperties3() { FreePnextChain(pNext); }
+
+void FormatProperties3::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 FormatProperties3::initialize(const FormatProperties3* 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);
+}
+
+PhysicalDeviceMaintenance4Features::PhysicalDeviceMaintenance4Features(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);
+    }
+}
+
+PhysicalDeviceMaintenance4Features::PhysicalDeviceMaintenance4Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES), pNext(nullptr), maintenance4() {}
+
+PhysicalDeviceMaintenance4Features::PhysicalDeviceMaintenance4Features(const PhysicalDeviceMaintenance4Features& copy_src) {
+    sType = copy_src.sType;
+    maintenance4 = copy_src.maintenance4;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMaintenance4Features& PhysicalDeviceMaintenance4Features::operator=(
+    const PhysicalDeviceMaintenance4Features& 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;
+}
+
+PhysicalDeviceMaintenance4Features::~PhysicalDeviceMaintenance4Features() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMaintenance4Features::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 PhysicalDeviceMaintenance4Features::initialize(const PhysicalDeviceMaintenance4Features* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maintenance4 = copy_src->maintenance4;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMaintenance4Properties::PhysicalDeviceMaintenance4Properties(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);
+    }
+}
+
+PhysicalDeviceMaintenance4Properties::PhysicalDeviceMaintenance4Properties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES), pNext(nullptr), maxBufferSize() {}
+
+PhysicalDeviceMaintenance4Properties::PhysicalDeviceMaintenance4Properties(const PhysicalDeviceMaintenance4Properties& copy_src) {
+    sType = copy_src.sType;
+    maxBufferSize = copy_src.maxBufferSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMaintenance4Properties& PhysicalDeviceMaintenance4Properties::operator=(
+    const PhysicalDeviceMaintenance4Properties& 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;
+}
+
+PhysicalDeviceMaintenance4Properties::~PhysicalDeviceMaintenance4Properties() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMaintenance4Properties::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 PhysicalDeviceMaintenance4Properties::initialize(const PhysicalDeviceMaintenance4Properties* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxBufferSize = copy_src->maxBufferSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DeviceBufferMemoryRequirements::DeviceBufferMemoryRequirements(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 BufferCreateInfo(in_struct->pCreateInfo);
+}
+
+DeviceBufferMemoryRequirements::DeviceBufferMemoryRequirements()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS), pNext(nullptr), pCreateInfo(nullptr) {}
+
+DeviceBufferMemoryRequirements::DeviceBufferMemoryRequirements(const DeviceBufferMemoryRequirements& copy_src) {
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new BufferCreateInfo(*copy_src.pCreateInfo);
+}
+
+DeviceBufferMemoryRequirements& DeviceBufferMemoryRequirements::operator=(const DeviceBufferMemoryRequirements& 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 BufferCreateInfo(*copy_src.pCreateInfo);
+
+    return *this;
+}
+
+DeviceBufferMemoryRequirements::~DeviceBufferMemoryRequirements() {
+    if (pCreateInfo) delete pCreateInfo;
+    FreePnextChain(pNext);
+}
+
+void DeviceBufferMemoryRequirements::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 BufferCreateInfo(in_struct->pCreateInfo);
+}
+
+void DeviceBufferMemoryRequirements::initialize(const DeviceBufferMemoryRequirements* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pCreateInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pCreateInfo) pCreateInfo = new BufferCreateInfo(*copy_src->pCreateInfo);
+}
+
+DeviceImageMemoryRequirements::DeviceImageMemoryRequirements(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 ImageCreateInfo(in_struct->pCreateInfo);
+}
+
+DeviceImageMemoryRequirements::DeviceImageMemoryRequirements()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS), pNext(nullptr), pCreateInfo(nullptr), planeAspect() {}
+
+DeviceImageMemoryRequirements::DeviceImageMemoryRequirements(const DeviceImageMemoryRequirements& copy_src) {
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    planeAspect = copy_src.planeAspect;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new ImageCreateInfo(*copy_src.pCreateInfo);
+}
+
+DeviceImageMemoryRequirements& DeviceImageMemoryRequirements::operator=(const DeviceImageMemoryRequirements& 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 ImageCreateInfo(*copy_src.pCreateInfo);
+
+    return *this;
+}
+
+DeviceImageMemoryRequirements::~DeviceImageMemoryRequirements() {
+    if (pCreateInfo) delete pCreateInfo;
+    FreePnextChain(pNext);
+}
+
+void DeviceImageMemoryRequirements::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 ImageCreateInfo(in_struct->pCreateInfo);
+}
+
+void DeviceImageMemoryRequirements::initialize(const DeviceImageMemoryRequirements* 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 ImageCreateInfo(*copy_src->pCreateInfo);
+}
+
+}  // namespace safe
+}  // 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..9210254
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -0,0 +1,15184 @@
+// *** 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 {
+namespace safe {
+
+RenderingFragmentDensityMapAttachmentInfoEXT::RenderingFragmentDensityMapAttachmentInfoEXT(
+    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);
+    }
+}
+
+RenderingFragmentDensityMapAttachmentInfoEXT::RenderingFragmentDensityMapAttachmentInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT), pNext(nullptr), imageView(), imageLayout() {}
+
+RenderingFragmentDensityMapAttachmentInfoEXT::RenderingFragmentDensityMapAttachmentInfoEXT(
+    const RenderingFragmentDensityMapAttachmentInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+RenderingFragmentDensityMapAttachmentInfoEXT& RenderingFragmentDensityMapAttachmentInfoEXT::operator=(
+    const RenderingFragmentDensityMapAttachmentInfoEXT& 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;
+}
+
+RenderingFragmentDensityMapAttachmentInfoEXT::~RenderingFragmentDensityMapAttachmentInfoEXT() { FreePnextChain(pNext); }
+
+void RenderingFragmentDensityMapAttachmentInfoEXT::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 RenderingFragmentDensityMapAttachmentInfoEXT::initialize(const RenderingFragmentDensityMapAttachmentInfoEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageView = copy_src->imageView;
+    imageLayout = copy_src->imageLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SetDescriptorBufferOffsetsInfoEXT::SetDescriptorBufferOffsetsInfoEXT(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);
+    }
+}
+
+SetDescriptorBufferOffsetsInfoEXT::SetDescriptorBufferOffsetsInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT),
+      pNext(nullptr),
+      stageFlags(),
+      layout(),
+      firstSet(),
+      setCount(),
+      pBufferIndices(nullptr),
+      pOffsets(nullptr) {}
+
+SetDescriptorBufferOffsetsInfoEXT::SetDescriptorBufferOffsetsInfoEXT(const SetDescriptorBufferOffsetsInfoEXT& 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);
+    }
+}
+
+SetDescriptorBufferOffsetsInfoEXT& SetDescriptorBufferOffsetsInfoEXT::operator=(const SetDescriptorBufferOffsetsInfoEXT& 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;
+}
+
+SetDescriptorBufferOffsetsInfoEXT::~SetDescriptorBufferOffsetsInfoEXT() {
+    if (pBufferIndices) delete[] pBufferIndices;
+    if (pOffsets) delete[] pOffsets;
+    FreePnextChain(pNext);
+}
+
+void SetDescriptorBufferOffsetsInfoEXT::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 SetDescriptorBufferOffsetsInfoEXT::initialize(const SetDescriptorBufferOffsetsInfoEXT* 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);
+    }
+}
+
+BindDescriptorBufferEmbeddedSamplersInfoEXT::BindDescriptorBufferEmbeddedSamplersInfoEXT(
+    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);
+    }
+}
+
+BindDescriptorBufferEmbeddedSamplersInfoEXT::BindDescriptorBufferEmbeddedSamplersInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT), pNext(nullptr), stageFlags(), layout(), set() {}
+
+BindDescriptorBufferEmbeddedSamplersInfoEXT::BindDescriptorBufferEmbeddedSamplersInfoEXT(
+    const BindDescriptorBufferEmbeddedSamplersInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BindDescriptorBufferEmbeddedSamplersInfoEXT& BindDescriptorBufferEmbeddedSamplersInfoEXT::operator=(
+    const BindDescriptorBufferEmbeddedSamplersInfoEXT& 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;
+}
+
+BindDescriptorBufferEmbeddedSamplersInfoEXT::~BindDescriptorBufferEmbeddedSamplersInfoEXT() { FreePnextChain(pNext); }
+
+void BindDescriptorBufferEmbeddedSamplersInfoEXT::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 BindDescriptorBufferEmbeddedSamplersInfoEXT::initialize(const BindDescriptorBufferEmbeddedSamplersInfoEXT* 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);
+}
+
+DebugReportCallbackCreateInfoEXT::DebugReportCallbackCreateInfoEXT(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);
+    }
+}
+
+DebugReportCallbackCreateInfoEXT::DebugReportCallbackCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT), pNext(nullptr), flags(), pfnCallback(), pUserData(nullptr) {}
+
+DebugReportCallbackCreateInfoEXT::DebugReportCallbackCreateInfoEXT(const DebugReportCallbackCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pfnCallback = copy_src.pfnCallback;
+    pUserData = copy_src.pUserData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DebugReportCallbackCreateInfoEXT& DebugReportCallbackCreateInfoEXT::operator=(const DebugReportCallbackCreateInfoEXT& 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;
+}
+
+DebugReportCallbackCreateInfoEXT::~DebugReportCallbackCreateInfoEXT() { FreePnextChain(pNext); }
+
+void DebugReportCallbackCreateInfoEXT::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 DebugReportCallbackCreateInfoEXT::initialize(const DebugReportCallbackCreateInfoEXT* 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);
+}
+
+DebugMarkerObjectNameInfoEXT::DebugMarkerObjectNameInfoEXT(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);
+}
+
+DebugMarkerObjectNameInfoEXT::DebugMarkerObjectNameInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT), pNext(nullptr), objectType(), object(), pObjectName(nullptr) {}
+
+DebugMarkerObjectNameInfoEXT::DebugMarkerObjectNameInfoEXT(const DebugMarkerObjectNameInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    objectType = copy_src.objectType;
+    object = copy_src.object;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pObjectName = SafeStringCopy(copy_src.pObjectName);
+}
+
+DebugMarkerObjectNameInfoEXT& DebugMarkerObjectNameInfoEXT::operator=(const DebugMarkerObjectNameInfoEXT& 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;
+}
+
+DebugMarkerObjectNameInfoEXT::~DebugMarkerObjectNameInfoEXT() {
+    if (pObjectName) delete[] pObjectName;
+    FreePnextChain(pNext);
+}
+
+void DebugMarkerObjectNameInfoEXT::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 DebugMarkerObjectNameInfoEXT::initialize(const DebugMarkerObjectNameInfoEXT* 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);
+}
+
+DebugMarkerObjectTagInfoEXT::DebugMarkerObjectTagInfoEXT(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);
+    }
+}
+
+DebugMarkerObjectTagInfoEXT::DebugMarkerObjectTagInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT),
+      pNext(nullptr),
+      objectType(),
+      object(),
+      tagName(),
+      tagSize(),
+      pTag(nullptr) {}
+
+DebugMarkerObjectTagInfoEXT::DebugMarkerObjectTagInfoEXT(const DebugMarkerObjectTagInfoEXT& 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);
+}
+
+DebugMarkerObjectTagInfoEXT& DebugMarkerObjectTagInfoEXT::operator=(const DebugMarkerObjectTagInfoEXT& 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;
+}
+
+DebugMarkerObjectTagInfoEXT::~DebugMarkerObjectTagInfoEXT() { FreePnextChain(pNext); }
+
+void DebugMarkerObjectTagInfoEXT::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 DebugMarkerObjectTagInfoEXT::initialize(const DebugMarkerObjectTagInfoEXT* 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);
+}
+
+DebugMarkerMarkerInfoEXT::DebugMarkerMarkerInfoEXT(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];
+    }
+}
+
+DebugMarkerMarkerInfoEXT::DebugMarkerMarkerInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT), pNext(nullptr), pMarkerName(nullptr) {}
+
+DebugMarkerMarkerInfoEXT::DebugMarkerMarkerInfoEXT(const DebugMarkerMarkerInfoEXT& 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];
+    }
+}
+
+DebugMarkerMarkerInfoEXT& DebugMarkerMarkerInfoEXT::operator=(const DebugMarkerMarkerInfoEXT& 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;
+}
+
+DebugMarkerMarkerInfoEXT::~DebugMarkerMarkerInfoEXT() {
+    if (pMarkerName) delete[] pMarkerName;
+    FreePnextChain(pNext);
+}
+
+void DebugMarkerMarkerInfoEXT::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 DebugMarkerMarkerInfoEXT::initialize(const DebugMarkerMarkerInfoEXT* 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];
+    }
+}
+
+PhysicalDeviceTransformFeedbackFeaturesEXT::PhysicalDeviceTransformFeedbackFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceTransformFeedbackFeaturesEXT::PhysicalDeviceTransformFeedbackFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT),
+      pNext(nullptr),
+      transformFeedback(),
+      geometryStreams() {}
+
+PhysicalDeviceTransformFeedbackFeaturesEXT::PhysicalDeviceTransformFeedbackFeaturesEXT(
+    const PhysicalDeviceTransformFeedbackFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    transformFeedback = copy_src.transformFeedback;
+    geometryStreams = copy_src.geometryStreams;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceTransformFeedbackFeaturesEXT& PhysicalDeviceTransformFeedbackFeaturesEXT::operator=(
+    const PhysicalDeviceTransformFeedbackFeaturesEXT& 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;
+}
+
+PhysicalDeviceTransformFeedbackFeaturesEXT::~PhysicalDeviceTransformFeedbackFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceTransformFeedbackFeaturesEXT::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 PhysicalDeviceTransformFeedbackFeaturesEXT::initialize(const PhysicalDeviceTransformFeedbackFeaturesEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    transformFeedback = copy_src->transformFeedback;
+    geometryStreams = copy_src->geometryStreams;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceTransformFeedbackPropertiesEXT::PhysicalDeviceTransformFeedbackPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceTransformFeedbackPropertiesEXT::PhysicalDeviceTransformFeedbackPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT),
+      pNext(nullptr),
+      maxTransformFeedbackStreams(),
+      maxTransformFeedbackBuffers(),
+      maxTransformFeedbackBufferSize(),
+      maxTransformFeedbackStreamDataSize(),
+      maxTransformFeedbackBufferDataSize(),
+      maxTransformFeedbackBufferDataStride(),
+      transformFeedbackQueries(),
+      transformFeedbackStreamsLinesTriangles(),
+      transformFeedbackRasterizationStreamSelect(),
+      transformFeedbackDraw() {}
+
+PhysicalDeviceTransformFeedbackPropertiesEXT::PhysicalDeviceTransformFeedbackPropertiesEXT(
+    const PhysicalDeviceTransformFeedbackPropertiesEXT& 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);
+}
+
+PhysicalDeviceTransformFeedbackPropertiesEXT& PhysicalDeviceTransformFeedbackPropertiesEXT::operator=(
+    const PhysicalDeviceTransformFeedbackPropertiesEXT& 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;
+}
+
+PhysicalDeviceTransformFeedbackPropertiesEXT::~PhysicalDeviceTransformFeedbackPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceTransformFeedbackPropertiesEXT::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 PhysicalDeviceTransformFeedbackPropertiesEXT::initialize(const PhysicalDeviceTransformFeedbackPropertiesEXT* 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);
+}
+
+PipelineRasterizationStateStreamCreateInfoEXT::PipelineRasterizationStateStreamCreateInfoEXT(
+    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);
+    }
+}
+
+PipelineRasterizationStateStreamCreateInfoEXT::PipelineRasterizationStateStreamCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      rasterizationStream() {}
+
+PipelineRasterizationStateStreamCreateInfoEXT::PipelineRasterizationStateStreamCreateInfoEXT(
+    const PipelineRasterizationStateStreamCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    rasterizationStream = copy_src.rasterizationStream;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineRasterizationStateStreamCreateInfoEXT& PipelineRasterizationStateStreamCreateInfoEXT::operator=(
+    const PipelineRasterizationStateStreamCreateInfoEXT& 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;
+}
+
+PipelineRasterizationStateStreamCreateInfoEXT::~PipelineRasterizationStateStreamCreateInfoEXT() { FreePnextChain(pNext); }
+
+void PipelineRasterizationStateStreamCreateInfoEXT::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 PipelineRasterizationStateStreamCreateInfoEXT::initialize(const PipelineRasterizationStateStreamCreateInfoEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    rasterizationStream = copy_src->rasterizationStream;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ValidationFlagsEXT::ValidationFlagsEXT(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);
+    }
+}
+
+ValidationFlagsEXT::ValidationFlagsEXT()
+    : sType(VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT),
+      pNext(nullptr),
+      disabledValidationCheckCount(),
+      pDisabledValidationChecks(nullptr) {}
+
+ValidationFlagsEXT::ValidationFlagsEXT(const ValidationFlagsEXT& 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);
+    }
+}
+
+ValidationFlagsEXT& ValidationFlagsEXT::operator=(const ValidationFlagsEXT& 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;
+}
+
+ValidationFlagsEXT::~ValidationFlagsEXT() {
+    if (pDisabledValidationChecks) delete[] pDisabledValidationChecks;
+    FreePnextChain(pNext);
+}
+
+void ValidationFlagsEXT::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 ValidationFlagsEXT::initialize(const ValidationFlagsEXT* 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);
+    }
+}
+
+ImageViewASTCDecodeModeEXT::ImageViewASTCDecodeModeEXT(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);
+    }
+}
+
+ImageViewASTCDecodeModeEXT::ImageViewASTCDecodeModeEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT), pNext(nullptr), decodeMode() {}
+
+ImageViewASTCDecodeModeEXT::ImageViewASTCDecodeModeEXT(const ImageViewASTCDecodeModeEXT& copy_src) {
+    sType = copy_src.sType;
+    decodeMode = copy_src.decodeMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageViewASTCDecodeModeEXT& ImageViewASTCDecodeModeEXT::operator=(const ImageViewASTCDecodeModeEXT& 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;
+}
+
+ImageViewASTCDecodeModeEXT::~ImageViewASTCDecodeModeEXT() { FreePnextChain(pNext); }
+
+void ImageViewASTCDecodeModeEXT::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 ImageViewASTCDecodeModeEXT::initialize(const ImageViewASTCDecodeModeEXT* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    decodeMode = copy_src->decodeMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceASTCDecodeFeaturesEXT::PhysicalDeviceASTCDecodeFeaturesEXT(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);
+    }
+}
+
+PhysicalDeviceASTCDecodeFeaturesEXT::PhysicalDeviceASTCDecodeFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT), pNext(nullptr), decodeModeSharedExponent() {}
+
+PhysicalDeviceASTCDecodeFeaturesEXT::PhysicalDeviceASTCDecodeFeaturesEXT(const PhysicalDeviceASTCDecodeFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    decodeModeSharedExponent = copy_src.decodeModeSharedExponent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceASTCDecodeFeaturesEXT& PhysicalDeviceASTCDecodeFeaturesEXT::operator=(
+    const PhysicalDeviceASTCDecodeFeaturesEXT& 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;
+}
+
+PhysicalDeviceASTCDecodeFeaturesEXT::~PhysicalDeviceASTCDecodeFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceASTCDecodeFeaturesEXT::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 PhysicalDeviceASTCDecodeFeaturesEXT::initialize(const PhysicalDeviceASTCDecodeFeaturesEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    decodeModeSharedExponent = copy_src->decodeModeSharedExponent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePipelineRobustnessFeaturesEXT::PhysicalDevicePipelineRobustnessFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDevicePipelineRobustnessFeaturesEXT::PhysicalDevicePipelineRobustnessFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT), pNext(nullptr), pipelineRobustness() {}
+
+PhysicalDevicePipelineRobustnessFeaturesEXT::PhysicalDevicePipelineRobustnessFeaturesEXT(
+    const PhysicalDevicePipelineRobustnessFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    pipelineRobustness = copy_src.pipelineRobustness;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePipelineRobustnessFeaturesEXT& PhysicalDevicePipelineRobustnessFeaturesEXT::operator=(
+    const PhysicalDevicePipelineRobustnessFeaturesEXT& 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;
+}
+
+PhysicalDevicePipelineRobustnessFeaturesEXT::~PhysicalDevicePipelineRobustnessFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDevicePipelineRobustnessFeaturesEXT::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 PhysicalDevicePipelineRobustnessFeaturesEXT::initialize(const PhysicalDevicePipelineRobustnessFeaturesEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineRobustness = copy_src->pipelineRobustness;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePipelineRobustnessPropertiesEXT::PhysicalDevicePipelineRobustnessPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDevicePipelineRobustnessPropertiesEXT::PhysicalDevicePipelineRobustnessPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT),
+      pNext(nullptr),
+      defaultRobustnessStorageBuffers(),
+      defaultRobustnessUniformBuffers(),
+      defaultRobustnessVertexInputs(),
+      defaultRobustnessImages() {}
+
+PhysicalDevicePipelineRobustnessPropertiesEXT::PhysicalDevicePipelineRobustnessPropertiesEXT(
+    const PhysicalDevicePipelineRobustnessPropertiesEXT& 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);
+}
+
+PhysicalDevicePipelineRobustnessPropertiesEXT& PhysicalDevicePipelineRobustnessPropertiesEXT::operator=(
+    const PhysicalDevicePipelineRobustnessPropertiesEXT& 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;
+}
+
+PhysicalDevicePipelineRobustnessPropertiesEXT::~PhysicalDevicePipelineRobustnessPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDevicePipelineRobustnessPropertiesEXT::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 PhysicalDevicePipelineRobustnessPropertiesEXT::initialize(const PhysicalDevicePipelineRobustnessPropertiesEXT* 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);
+}
+
+PipelineRobustnessCreateInfoEXT::PipelineRobustnessCreateInfoEXT(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);
+    }
+}
+
+PipelineRobustnessCreateInfoEXT::PipelineRobustnessCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT),
+      pNext(nullptr),
+      storageBuffers(),
+      uniformBuffers(),
+      vertexInputs(),
+      images() {}
+
+PipelineRobustnessCreateInfoEXT::PipelineRobustnessCreateInfoEXT(const PipelineRobustnessCreateInfoEXT& 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);
+}
+
+PipelineRobustnessCreateInfoEXT& PipelineRobustnessCreateInfoEXT::operator=(const PipelineRobustnessCreateInfoEXT& 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;
+}
+
+PipelineRobustnessCreateInfoEXT::~PipelineRobustnessCreateInfoEXT() { FreePnextChain(pNext); }
+
+void PipelineRobustnessCreateInfoEXT::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 PipelineRobustnessCreateInfoEXT::initialize(const PipelineRobustnessCreateInfoEXT* 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);
+}
+
+ConditionalRenderingBeginInfoEXT::ConditionalRenderingBeginInfoEXT(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);
+    }
+}
+
+ConditionalRenderingBeginInfoEXT::ConditionalRenderingBeginInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT), pNext(nullptr), buffer(), offset(), flags() {}
+
+ConditionalRenderingBeginInfoEXT::ConditionalRenderingBeginInfoEXT(const ConditionalRenderingBeginInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ConditionalRenderingBeginInfoEXT& ConditionalRenderingBeginInfoEXT::operator=(const ConditionalRenderingBeginInfoEXT& 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;
+}
+
+ConditionalRenderingBeginInfoEXT::~ConditionalRenderingBeginInfoEXT() { FreePnextChain(pNext); }
+
+void ConditionalRenderingBeginInfoEXT::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 ConditionalRenderingBeginInfoEXT::initialize(const ConditionalRenderingBeginInfoEXT* 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);
+}
+
+PhysicalDeviceConditionalRenderingFeaturesEXT::PhysicalDeviceConditionalRenderingFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceConditionalRenderingFeaturesEXT::PhysicalDeviceConditionalRenderingFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT),
+      pNext(nullptr),
+      conditionalRendering(),
+      inheritedConditionalRendering() {}
+
+PhysicalDeviceConditionalRenderingFeaturesEXT::PhysicalDeviceConditionalRenderingFeaturesEXT(
+    const PhysicalDeviceConditionalRenderingFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    conditionalRendering = copy_src.conditionalRendering;
+    inheritedConditionalRendering = copy_src.inheritedConditionalRendering;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceConditionalRenderingFeaturesEXT& PhysicalDeviceConditionalRenderingFeaturesEXT::operator=(
+    const PhysicalDeviceConditionalRenderingFeaturesEXT& 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;
+}
+
+PhysicalDeviceConditionalRenderingFeaturesEXT::~PhysicalDeviceConditionalRenderingFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceConditionalRenderingFeaturesEXT::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 PhysicalDeviceConditionalRenderingFeaturesEXT::initialize(const PhysicalDeviceConditionalRenderingFeaturesEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    conditionalRendering = copy_src->conditionalRendering;
+    inheritedConditionalRendering = copy_src->inheritedConditionalRendering;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CommandBufferInheritanceConditionalRenderingInfoEXT::CommandBufferInheritanceConditionalRenderingInfoEXT(
+    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);
+    }
+}
+
+CommandBufferInheritanceConditionalRenderingInfoEXT::CommandBufferInheritanceConditionalRenderingInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT),
+      pNext(nullptr),
+      conditionalRenderingEnable() {}
+
+CommandBufferInheritanceConditionalRenderingInfoEXT::CommandBufferInheritanceConditionalRenderingInfoEXT(
+    const CommandBufferInheritanceConditionalRenderingInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    conditionalRenderingEnable = copy_src.conditionalRenderingEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CommandBufferInheritanceConditionalRenderingInfoEXT& CommandBufferInheritanceConditionalRenderingInfoEXT::operator=(
+    const CommandBufferInheritanceConditionalRenderingInfoEXT& 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;
+}
+
+CommandBufferInheritanceConditionalRenderingInfoEXT::~CommandBufferInheritanceConditionalRenderingInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void CommandBufferInheritanceConditionalRenderingInfoEXT::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 CommandBufferInheritanceConditionalRenderingInfoEXT::initialize(
+    const CommandBufferInheritanceConditionalRenderingInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    conditionalRenderingEnable = copy_src->conditionalRenderingEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SurfaceCapabilities2EXT::SurfaceCapabilities2EXT(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);
+    }
+}
+
+SurfaceCapabilities2EXT::SurfaceCapabilities2EXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT),
+      pNext(nullptr),
+      minImageCount(),
+      maxImageCount(),
+      currentExtent(),
+      minImageExtent(),
+      maxImageExtent(),
+      maxImageArrayLayers(),
+      supportedTransforms(),
+      currentTransform(),
+      supportedCompositeAlpha(),
+      supportedUsageFlags(),
+      supportedSurfaceCounters() {}
+
+SurfaceCapabilities2EXT::SurfaceCapabilities2EXT(const SurfaceCapabilities2EXT& 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);
+}
+
+SurfaceCapabilities2EXT& SurfaceCapabilities2EXT::operator=(const SurfaceCapabilities2EXT& 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;
+}
+
+SurfaceCapabilities2EXT::~SurfaceCapabilities2EXT() { FreePnextChain(pNext); }
+
+void SurfaceCapabilities2EXT::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 SurfaceCapabilities2EXT::initialize(const SurfaceCapabilities2EXT* 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);
+}
+
+DisplayPowerInfoEXT::DisplayPowerInfoEXT(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);
+    }
+}
+
+DisplayPowerInfoEXT::DisplayPowerInfoEXT() : sType(VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT), pNext(nullptr), powerState() {}
+
+DisplayPowerInfoEXT::DisplayPowerInfoEXT(const DisplayPowerInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    powerState = copy_src.powerState;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DisplayPowerInfoEXT& DisplayPowerInfoEXT::operator=(const DisplayPowerInfoEXT& 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;
+}
+
+DisplayPowerInfoEXT::~DisplayPowerInfoEXT() { FreePnextChain(pNext); }
+
+void DisplayPowerInfoEXT::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 DisplayPowerInfoEXT::initialize(const DisplayPowerInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    powerState = copy_src->powerState;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DeviceEventInfoEXT::DeviceEventInfoEXT(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);
+    }
+}
+
+DeviceEventInfoEXT::DeviceEventInfoEXT() : sType(VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT), pNext(nullptr), deviceEvent() {}
+
+DeviceEventInfoEXT::DeviceEventInfoEXT(const DeviceEventInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    deviceEvent = copy_src.deviceEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceEventInfoEXT& DeviceEventInfoEXT::operator=(const DeviceEventInfoEXT& 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;
+}
+
+DeviceEventInfoEXT::~DeviceEventInfoEXT() { FreePnextChain(pNext); }
+
+void DeviceEventInfoEXT::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 DeviceEventInfoEXT::initialize(const DeviceEventInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceEvent = copy_src->deviceEvent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DisplayEventInfoEXT::DisplayEventInfoEXT(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);
+    }
+}
+
+DisplayEventInfoEXT::DisplayEventInfoEXT() : sType(VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT), pNext(nullptr), displayEvent() {}
+
+DisplayEventInfoEXT::DisplayEventInfoEXT(const DisplayEventInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    displayEvent = copy_src.displayEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DisplayEventInfoEXT& DisplayEventInfoEXT::operator=(const DisplayEventInfoEXT& 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;
+}
+
+DisplayEventInfoEXT::~DisplayEventInfoEXT() { FreePnextChain(pNext); }
+
+void DisplayEventInfoEXT::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 DisplayEventInfoEXT::initialize(const DisplayEventInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displayEvent = copy_src->displayEvent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SwapchainCounterCreateInfoEXT::SwapchainCounterCreateInfoEXT(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);
+    }
+}
+
+SwapchainCounterCreateInfoEXT::SwapchainCounterCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT), pNext(nullptr), surfaceCounters() {}
+
+SwapchainCounterCreateInfoEXT::SwapchainCounterCreateInfoEXT(const SwapchainCounterCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    surfaceCounters = copy_src.surfaceCounters;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SwapchainCounterCreateInfoEXT& SwapchainCounterCreateInfoEXT::operator=(const SwapchainCounterCreateInfoEXT& 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;
+}
+
+SwapchainCounterCreateInfoEXT::~SwapchainCounterCreateInfoEXT() { FreePnextChain(pNext); }
+
+void SwapchainCounterCreateInfoEXT::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 SwapchainCounterCreateInfoEXT::initialize(const SwapchainCounterCreateInfoEXT* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    surfaceCounters = copy_src->surfaceCounters;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDiscardRectanglePropertiesEXT::PhysicalDeviceDiscardRectanglePropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceDiscardRectanglePropertiesEXT::PhysicalDeviceDiscardRectanglePropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT), pNext(nullptr), maxDiscardRectangles() {}
+
+PhysicalDeviceDiscardRectanglePropertiesEXT::PhysicalDeviceDiscardRectanglePropertiesEXT(
+    const PhysicalDeviceDiscardRectanglePropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxDiscardRectangles = copy_src.maxDiscardRectangles;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDiscardRectanglePropertiesEXT& PhysicalDeviceDiscardRectanglePropertiesEXT::operator=(
+    const PhysicalDeviceDiscardRectanglePropertiesEXT& 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;
+}
+
+PhysicalDeviceDiscardRectanglePropertiesEXT::~PhysicalDeviceDiscardRectanglePropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDiscardRectanglePropertiesEXT::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 PhysicalDeviceDiscardRectanglePropertiesEXT::initialize(const PhysicalDeviceDiscardRectanglePropertiesEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxDiscardRectangles = copy_src->maxDiscardRectangles;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineDiscardRectangleStateCreateInfoEXT::PipelineDiscardRectangleStateCreateInfoEXT(
+    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);
+    }
+}
+
+PipelineDiscardRectangleStateCreateInfoEXT::PipelineDiscardRectangleStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      discardRectangleMode(),
+      discardRectangleCount(),
+      pDiscardRectangles(nullptr) {}
+
+PipelineDiscardRectangleStateCreateInfoEXT::PipelineDiscardRectangleStateCreateInfoEXT(
+    const PipelineDiscardRectangleStateCreateInfoEXT& 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);
+    }
+}
+
+PipelineDiscardRectangleStateCreateInfoEXT& PipelineDiscardRectangleStateCreateInfoEXT::operator=(
+    const PipelineDiscardRectangleStateCreateInfoEXT& 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;
+}
+
+PipelineDiscardRectangleStateCreateInfoEXT::~PipelineDiscardRectangleStateCreateInfoEXT() {
+    if (pDiscardRectangles) delete[] pDiscardRectangles;
+    FreePnextChain(pNext);
+}
+
+void PipelineDiscardRectangleStateCreateInfoEXT::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 PipelineDiscardRectangleStateCreateInfoEXT::initialize(const PipelineDiscardRectangleStateCreateInfoEXT* 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);
+    }
+}
+
+PhysicalDeviceConservativeRasterizationPropertiesEXT::PhysicalDeviceConservativeRasterizationPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceConservativeRasterizationPropertiesEXT::PhysicalDeviceConservativeRasterizationPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT),
+      pNext(nullptr),
+      primitiveOverestimationSize(),
+      maxExtraPrimitiveOverestimationSize(),
+      extraPrimitiveOverestimationSizeGranularity(),
+      primitiveUnderestimation(),
+      conservativePointAndLineRasterization(),
+      degenerateTrianglesRasterized(),
+      degenerateLinesRasterized(),
+      fullyCoveredFragmentShaderInputVariable(),
+      conservativeRasterizationPostDepthCoverage() {}
+
+PhysicalDeviceConservativeRasterizationPropertiesEXT::PhysicalDeviceConservativeRasterizationPropertiesEXT(
+    const PhysicalDeviceConservativeRasterizationPropertiesEXT& 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);
+}
+
+PhysicalDeviceConservativeRasterizationPropertiesEXT& PhysicalDeviceConservativeRasterizationPropertiesEXT::operator=(
+    const PhysicalDeviceConservativeRasterizationPropertiesEXT& 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;
+}
+
+PhysicalDeviceConservativeRasterizationPropertiesEXT::~PhysicalDeviceConservativeRasterizationPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceConservativeRasterizationPropertiesEXT::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 PhysicalDeviceConservativeRasterizationPropertiesEXT::initialize(
+    const PhysicalDeviceConservativeRasterizationPropertiesEXT* 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);
+}
+
+PipelineRasterizationConservativeStateCreateInfoEXT::PipelineRasterizationConservativeStateCreateInfoEXT(
+    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);
+    }
+}
+
+PipelineRasterizationConservativeStateCreateInfoEXT::PipelineRasterizationConservativeStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      conservativeRasterizationMode(),
+      extraPrimitiveOverestimationSize() {}
+
+PipelineRasterizationConservativeStateCreateInfoEXT::PipelineRasterizationConservativeStateCreateInfoEXT(
+    const PipelineRasterizationConservativeStateCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    conservativeRasterizationMode = copy_src.conservativeRasterizationMode;
+    extraPrimitiveOverestimationSize = copy_src.extraPrimitiveOverestimationSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineRasterizationConservativeStateCreateInfoEXT& PipelineRasterizationConservativeStateCreateInfoEXT::operator=(
+    const PipelineRasterizationConservativeStateCreateInfoEXT& 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;
+}
+
+PipelineRasterizationConservativeStateCreateInfoEXT::~PipelineRasterizationConservativeStateCreateInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void PipelineRasterizationConservativeStateCreateInfoEXT::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 PipelineRasterizationConservativeStateCreateInfoEXT::initialize(
+    const PipelineRasterizationConservativeStateCreateInfoEXT* 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);
+}
+
+PhysicalDeviceDepthClipEnableFeaturesEXT::PhysicalDeviceDepthClipEnableFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceDepthClipEnableFeaturesEXT::PhysicalDeviceDepthClipEnableFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT), pNext(nullptr), depthClipEnable() {}
+
+PhysicalDeviceDepthClipEnableFeaturesEXT::PhysicalDeviceDepthClipEnableFeaturesEXT(
+    const PhysicalDeviceDepthClipEnableFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    depthClipEnable = copy_src.depthClipEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDepthClipEnableFeaturesEXT& PhysicalDeviceDepthClipEnableFeaturesEXT::operator=(
+    const PhysicalDeviceDepthClipEnableFeaturesEXT& 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;
+}
+
+PhysicalDeviceDepthClipEnableFeaturesEXT::~PhysicalDeviceDepthClipEnableFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDepthClipEnableFeaturesEXT::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 PhysicalDeviceDepthClipEnableFeaturesEXT::initialize(const PhysicalDeviceDepthClipEnableFeaturesEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthClipEnable = copy_src->depthClipEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineRasterizationDepthClipStateCreateInfoEXT::PipelineRasterizationDepthClipStateCreateInfoEXT(
+    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);
+    }
+}
+
+PipelineRasterizationDepthClipStateCreateInfoEXT::PipelineRasterizationDepthClipStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      depthClipEnable() {}
+
+PipelineRasterizationDepthClipStateCreateInfoEXT::PipelineRasterizationDepthClipStateCreateInfoEXT(
+    const PipelineRasterizationDepthClipStateCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    depthClipEnable = copy_src.depthClipEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineRasterizationDepthClipStateCreateInfoEXT& PipelineRasterizationDepthClipStateCreateInfoEXT::operator=(
+    const PipelineRasterizationDepthClipStateCreateInfoEXT& 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;
+}
+
+PipelineRasterizationDepthClipStateCreateInfoEXT::~PipelineRasterizationDepthClipStateCreateInfoEXT() { FreePnextChain(pNext); }
+
+void PipelineRasterizationDepthClipStateCreateInfoEXT::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 PipelineRasterizationDepthClipStateCreateInfoEXT::initialize(const PipelineRasterizationDepthClipStateCreateInfoEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    depthClipEnable = copy_src->depthClipEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+HdrMetadataEXT::HdrMetadataEXT(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);
+    }
+}
+
+HdrMetadataEXT::HdrMetadataEXT()
+    : sType(VK_STRUCTURE_TYPE_HDR_METADATA_EXT),
+      pNext(nullptr),
+      displayPrimaryRed(),
+      displayPrimaryGreen(),
+      displayPrimaryBlue(),
+      whitePoint(),
+      maxLuminance(),
+      minLuminance(),
+      maxContentLightLevel(),
+      maxFrameAverageLightLevel() {}
+
+HdrMetadataEXT::HdrMetadataEXT(const HdrMetadataEXT& 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);
+}
+
+HdrMetadataEXT& HdrMetadataEXT::operator=(const HdrMetadataEXT& 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;
+}
+
+HdrMetadataEXT::~HdrMetadataEXT() { FreePnextChain(pNext); }
+
+void HdrMetadataEXT::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 HdrMetadataEXT::initialize(const HdrMetadataEXT* 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);
+}
+
+DebugUtilsLabelEXT::DebugUtilsLabelEXT(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];
+    }
+}
+
+DebugUtilsLabelEXT::DebugUtilsLabelEXT() : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT), pNext(nullptr), pLabelName(nullptr) {}
+
+DebugUtilsLabelEXT::DebugUtilsLabelEXT(const DebugUtilsLabelEXT& 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];
+    }
+}
+
+DebugUtilsLabelEXT& DebugUtilsLabelEXT::operator=(const DebugUtilsLabelEXT& 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;
+}
+
+DebugUtilsLabelEXT::~DebugUtilsLabelEXT() {
+    if (pLabelName) delete[] pLabelName;
+    FreePnextChain(pNext);
+}
+
+void DebugUtilsLabelEXT::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 DebugUtilsLabelEXT::initialize(const DebugUtilsLabelEXT* 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];
+    }
+}
+
+DebugUtilsObjectNameInfoEXT::DebugUtilsObjectNameInfoEXT(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);
+}
+
+DebugUtilsObjectNameInfoEXT::DebugUtilsObjectNameInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT),
+      pNext(nullptr),
+      objectType(),
+      objectHandle(),
+      pObjectName(nullptr) {}
+
+DebugUtilsObjectNameInfoEXT::DebugUtilsObjectNameInfoEXT(const DebugUtilsObjectNameInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    objectType = copy_src.objectType;
+    objectHandle = copy_src.objectHandle;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pObjectName = SafeStringCopy(copy_src.pObjectName);
+}
+
+DebugUtilsObjectNameInfoEXT& DebugUtilsObjectNameInfoEXT::operator=(const DebugUtilsObjectNameInfoEXT& 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;
+}
+
+DebugUtilsObjectNameInfoEXT::~DebugUtilsObjectNameInfoEXT() {
+    if (pObjectName) delete[] pObjectName;
+    FreePnextChain(pNext);
+}
+
+void DebugUtilsObjectNameInfoEXT::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 DebugUtilsObjectNameInfoEXT::initialize(const DebugUtilsObjectNameInfoEXT* 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);
+}
+
+DebugUtilsMessengerCallbackDataEXT::DebugUtilsMessengerCallbackDataEXT(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 DebugUtilsLabelEXT[queueLabelCount];
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
+            pQueueLabels[i].initialize(&in_struct->pQueueLabels[i]);
+        }
+    }
+    if (cmdBufLabelCount && in_struct->pCmdBufLabels) {
+        pCmdBufLabels = new DebugUtilsLabelEXT[cmdBufLabelCount];
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
+            pCmdBufLabels[i].initialize(&in_struct->pCmdBufLabels[i]);
+        }
+    }
+    if (objectCount && in_struct->pObjects) {
+        pObjects = new DebugUtilsObjectNameInfoEXT[objectCount];
+        for (uint32_t i = 0; i < objectCount; ++i) {
+            pObjects[i].initialize(&in_struct->pObjects[i]);
+        }
+    }
+}
+
+DebugUtilsMessengerCallbackDataEXT::DebugUtilsMessengerCallbackDataEXT()
+    : 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) {}
+
+DebugUtilsMessengerCallbackDataEXT::DebugUtilsMessengerCallbackDataEXT(const DebugUtilsMessengerCallbackDataEXT& 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 DebugUtilsLabelEXT[queueLabelCount];
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
+            pQueueLabels[i].initialize(&copy_src.pQueueLabels[i]);
+        }
+    }
+    if (cmdBufLabelCount && copy_src.pCmdBufLabels) {
+        pCmdBufLabels = new DebugUtilsLabelEXT[cmdBufLabelCount];
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
+            pCmdBufLabels[i].initialize(&copy_src.pCmdBufLabels[i]);
+        }
+    }
+    if (objectCount && copy_src.pObjects) {
+        pObjects = new DebugUtilsObjectNameInfoEXT[objectCount];
+        for (uint32_t i = 0; i < objectCount; ++i) {
+            pObjects[i].initialize(&copy_src.pObjects[i]);
+        }
+    }
+}
+
+DebugUtilsMessengerCallbackDataEXT& DebugUtilsMessengerCallbackDataEXT::operator=(
+    const DebugUtilsMessengerCallbackDataEXT& 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 DebugUtilsLabelEXT[queueLabelCount];
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
+            pQueueLabels[i].initialize(&copy_src.pQueueLabels[i]);
+        }
+    }
+    if (cmdBufLabelCount && copy_src.pCmdBufLabels) {
+        pCmdBufLabels = new DebugUtilsLabelEXT[cmdBufLabelCount];
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
+            pCmdBufLabels[i].initialize(&copy_src.pCmdBufLabels[i]);
+        }
+    }
+    if (objectCount && copy_src.pObjects) {
+        pObjects = new DebugUtilsObjectNameInfoEXT[objectCount];
+        for (uint32_t i = 0; i < objectCount; ++i) {
+            pObjects[i].initialize(&copy_src.pObjects[i]);
+        }
+    }
+
+    return *this;
+}
+
+DebugUtilsMessengerCallbackDataEXT::~DebugUtilsMessengerCallbackDataEXT() {
+    if (pMessageIdName) delete[] pMessageIdName;
+    if (pMessage) delete[] pMessage;
+    if (pQueueLabels) delete[] pQueueLabels;
+    if (pCmdBufLabels) delete[] pCmdBufLabels;
+    if (pObjects) delete[] pObjects;
+    FreePnextChain(pNext);
+}
+
+void DebugUtilsMessengerCallbackDataEXT::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 DebugUtilsLabelEXT[queueLabelCount];
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
+            pQueueLabels[i].initialize(&in_struct->pQueueLabels[i]);
+        }
+    }
+    if (cmdBufLabelCount && in_struct->pCmdBufLabels) {
+        pCmdBufLabels = new DebugUtilsLabelEXT[cmdBufLabelCount];
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
+            pCmdBufLabels[i].initialize(&in_struct->pCmdBufLabels[i]);
+        }
+    }
+    if (objectCount && in_struct->pObjects) {
+        pObjects = new DebugUtilsObjectNameInfoEXT[objectCount];
+        for (uint32_t i = 0; i < objectCount; ++i) {
+            pObjects[i].initialize(&in_struct->pObjects[i]);
+        }
+    }
+}
+
+void DebugUtilsMessengerCallbackDataEXT::initialize(const DebugUtilsMessengerCallbackDataEXT* 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 DebugUtilsLabelEXT[queueLabelCount];
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
+            pQueueLabels[i].initialize(&copy_src->pQueueLabels[i]);
+        }
+    }
+    if (cmdBufLabelCount && copy_src->pCmdBufLabels) {
+        pCmdBufLabels = new DebugUtilsLabelEXT[cmdBufLabelCount];
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
+            pCmdBufLabels[i].initialize(&copy_src->pCmdBufLabels[i]);
+        }
+    }
+    if (objectCount && copy_src->pObjects) {
+        pObjects = new DebugUtilsObjectNameInfoEXT[objectCount];
+        for (uint32_t i = 0; i < objectCount; ++i) {
+            pObjects[i].initialize(&copy_src->pObjects[i]);
+        }
+    }
+}
+
+DebugUtilsMessengerCreateInfoEXT::DebugUtilsMessengerCreateInfoEXT(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);
+    }
+}
+
+DebugUtilsMessengerCreateInfoEXT::DebugUtilsMessengerCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      messageSeverity(),
+      messageType(),
+      pfnUserCallback(),
+      pUserData(nullptr) {}
+
+DebugUtilsMessengerCreateInfoEXT::DebugUtilsMessengerCreateInfoEXT(const DebugUtilsMessengerCreateInfoEXT& 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);
+}
+
+DebugUtilsMessengerCreateInfoEXT& DebugUtilsMessengerCreateInfoEXT::operator=(const DebugUtilsMessengerCreateInfoEXT& 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;
+}
+
+DebugUtilsMessengerCreateInfoEXT::~DebugUtilsMessengerCreateInfoEXT() { FreePnextChain(pNext); }
+
+void DebugUtilsMessengerCreateInfoEXT::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 DebugUtilsMessengerCreateInfoEXT::initialize(const DebugUtilsMessengerCreateInfoEXT* 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);
+}
+
+DebugUtilsObjectTagInfoEXT::DebugUtilsObjectTagInfoEXT(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);
+    }
+}
+
+DebugUtilsObjectTagInfoEXT::DebugUtilsObjectTagInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT),
+      pNext(nullptr),
+      objectType(),
+      objectHandle(),
+      tagName(),
+      tagSize(),
+      pTag(nullptr) {}
+
+DebugUtilsObjectTagInfoEXT::DebugUtilsObjectTagInfoEXT(const DebugUtilsObjectTagInfoEXT& 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);
+}
+
+DebugUtilsObjectTagInfoEXT& DebugUtilsObjectTagInfoEXT::operator=(const DebugUtilsObjectTagInfoEXT& 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;
+}
+
+DebugUtilsObjectTagInfoEXT::~DebugUtilsObjectTagInfoEXT() { FreePnextChain(pNext); }
+
+void DebugUtilsObjectTagInfoEXT::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 DebugUtilsObjectTagInfoEXT::initialize(const DebugUtilsObjectTagInfoEXT* 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);
+}
+
+SampleLocationsInfoEXT::SampleLocationsInfoEXT(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);
+    }
+}
+
+SampleLocationsInfoEXT::SampleLocationsInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT),
+      pNext(nullptr),
+      sampleLocationsPerPixel(),
+      sampleLocationGridSize(),
+      sampleLocationsCount(),
+      pSampleLocations(nullptr) {}
+
+SampleLocationsInfoEXT::SampleLocationsInfoEXT(const SampleLocationsInfoEXT& 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);
+    }
+}
+
+SampleLocationsInfoEXT& SampleLocationsInfoEXT::operator=(const SampleLocationsInfoEXT& 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;
+}
+
+SampleLocationsInfoEXT::~SampleLocationsInfoEXT() {
+    if (pSampleLocations) delete[] pSampleLocations;
+    FreePnextChain(pNext);
+}
+
+void SampleLocationsInfoEXT::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 SampleLocationsInfoEXT::initialize(const SampleLocationsInfoEXT* 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);
+    }
+}
+
+RenderPassSampleLocationsBeginInfoEXT::RenderPassSampleLocationsBeginInfoEXT(
+    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);
+    }
+}
+
+RenderPassSampleLocationsBeginInfoEXT::RenderPassSampleLocationsBeginInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT),
+      pNext(nullptr),
+      attachmentInitialSampleLocationsCount(),
+      pAttachmentInitialSampleLocations(nullptr),
+      postSubpassSampleLocationsCount(),
+      pPostSubpassSampleLocations(nullptr) {}
+
+RenderPassSampleLocationsBeginInfoEXT::RenderPassSampleLocationsBeginInfoEXT(
+    const RenderPassSampleLocationsBeginInfoEXT& 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);
+    }
+}
+
+RenderPassSampleLocationsBeginInfoEXT& RenderPassSampleLocationsBeginInfoEXT::operator=(
+    const RenderPassSampleLocationsBeginInfoEXT& 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;
+}
+
+RenderPassSampleLocationsBeginInfoEXT::~RenderPassSampleLocationsBeginInfoEXT() {
+    if (pAttachmentInitialSampleLocations) delete[] pAttachmentInitialSampleLocations;
+    if (pPostSubpassSampleLocations) delete[] pPostSubpassSampleLocations;
+    FreePnextChain(pNext);
+}
+
+void RenderPassSampleLocationsBeginInfoEXT::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 RenderPassSampleLocationsBeginInfoEXT::initialize(const RenderPassSampleLocationsBeginInfoEXT* 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);
+    }
+}
+
+PipelineSampleLocationsStateCreateInfoEXT::PipelineSampleLocationsStateCreateInfoEXT(
+    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);
+    }
+}
+
+PipelineSampleLocationsStateCreateInfoEXT::PipelineSampleLocationsStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT), pNext(nullptr), sampleLocationsEnable() {}
+
+PipelineSampleLocationsStateCreateInfoEXT::PipelineSampleLocationsStateCreateInfoEXT(
+    const PipelineSampleLocationsStateCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    sampleLocationsEnable = copy_src.sampleLocationsEnable;
+    sampleLocationsInfo.initialize(&copy_src.sampleLocationsInfo);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineSampleLocationsStateCreateInfoEXT& PipelineSampleLocationsStateCreateInfoEXT::operator=(
+    const PipelineSampleLocationsStateCreateInfoEXT& 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;
+}
+
+PipelineSampleLocationsStateCreateInfoEXT::~PipelineSampleLocationsStateCreateInfoEXT() { FreePnextChain(pNext); }
+
+void PipelineSampleLocationsStateCreateInfoEXT::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 PipelineSampleLocationsStateCreateInfoEXT::initialize(const PipelineSampleLocationsStateCreateInfoEXT* 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);
+}
+
+PhysicalDeviceSampleLocationsPropertiesEXT::PhysicalDeviceSampleLocationsPropertiesEXT(
+    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];
+    }
+}
+
+PhysicalDeviceSampleLocationsPropertiesEXT::PhysicalDeviceSampleLocationsPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT),
+      pNext(nullptr),
+      sampleLocationSampleCounts(),
+      maxSampleLocationGridSize(),
+      sampleLocationSubPixelBits(),
+      variableSampleLocations() {}
+
+PhysicalDeviceSampleLocationsPropertiesEXT::PhysicalDeviceSampleLocationsPropertiesEXT(
+    const PhysicalDeviceSampleLocationsPropertiesEXT& 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];
+    }
+}
+
+PhysicalDeviceSampleLocationsPropertiesEXT& PhysicalDeviceSampleLocationsPropertiesEXT::operator=(
+    const PhysicalDeviceSampleLocationsPropertiesEXT& 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;
+}
+
+PhysicalDeviceSampleLocationsPropertiesEXT::~PhysicalDeviceSampleLocationsPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSampleLocationsPropertiesEXT::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 PhysicalDeviceSampleLocationsPropertiesEXT::initialize(const PhysicalDeviceSampleLocationsPropertiesEXT* 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];
+    }
+}
+
+MultisamplePropertiesEXT::MultisamplePropertiesEXT(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);
+    }
+}
+
+MultisamplePropertiesEXT::MultisamplePropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT), pNext(nullptr), maxSampleLocationGridSize() {}
+
+MultisamplePropertiesEXT::MultisamplePropertiesEXT(const MultisamplePropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MultisamplePropertiesEXT& MultisamplePropertiesEXT::operator=(const MultisamplePropertiesEXT& 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;
+}
+
+MultisamplePropertiesEXT::~MultisamplePropertiesEXT() { FreePnextChain(pNext); }
+
+void MultisamplePropertiesEXT::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 MultisamplePropertiesEXT::initialize(const MultisamplePropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxSampleLocationGridSize = copy_src->maxSampleLocationGridSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceBlendOperationAdvancedFeaturesEXT::PhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceBlendOperationAdvancedFeaturesEXT::PhysicalDeviceBlendOperationAdvancedFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT),
+      pNext(nullptr),
+      advancedBlendCoherentOperations() {}
+
+PhysicalDeviceBlendOperationAdvancedFeaturesEXT::PhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    const PhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    advancedBlendCoherentOperations = copy_src.advancedBlendCoherentOperations;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceBlendOperationAdvancedFeaturesEXT& PhysicalDeviceBlendOperationAdvancedFeaturesEXT::operator=(
+    const PhysicalDeviceBlendOperationAdvancedFeaturesEXT& 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;
+}
+
+PhysicalDeviceBlendOperationAdvancedFeaturesEXT::~PhysicalDeviceBlendOperationAdvancedFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceBlendOperationAdvancedFeaturesEXT::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 PhysicalDeviceBlendOperationAdvancedFeaturesEXT::initialize(const PhysicalDeviceBlendOperationAdvancedFeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    advancedBlendCoherentOperations = copy_src->advancedBlendCoherentOperations;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceBlendOperationAdvancedPropertiesEXT::PhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceBlendOperationAdvancedPropertiesEXT::PhysicalDeviceBlendOperationAdvancedPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT),
+      pNext(nullptr),
+      advancedBlendMaxColorAttachments(),
+      advancedBlendIndependentBlend(),
+      advancedBlendNonPremultipliedSrcColor(),
+      advancedBlendNonPremultipliedDstColor(),
+      advancedBlendCorrelatedOverlap(),
+      advancedBlendAllOperations() {}
+
+PhysicalDeviceBlendOperationAdvancedPropertiesEXT::PhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    const PhysicalDeviceBlendOperationAdvancedPropertiesEXT& 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);
+}
+
+PhysicalDeviceBlendOperationAdvancedPropertiesEXT& PhysicalDeviceBlendOperationAdvancedPropertiesEXT::operator=(
+    const PhysicalDeviceBlendOperationAdvancedPropertiesEXT& 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;
+}
+
+PhysicalDeviceBlendOperationAdvancedPropertiesEXT::~PhysicalDeviceBlendOperationAdvancedPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceBlendOperationAdvancedPropertiesEXT::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 PhysicalDeviceBlendOperationAdvancedPropertiesEXT::initialize(
+    const PhysicalDeviceBlendOperationAdvancedPropertiesEXT* 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);
+}
+
+PipelineColorBlendAdvancedStateCreateInfoEXT::PipelineColorBlendAdvancedStateCreateInfoEXT(
+    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);
+    }
+}
+
+PipelineColorBlendAdvancedStateCreateInfoEXT::PipelineColorBlendAdvancedStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      srcPremultiplied(),
+      dstPremultiplied(),
+      blendOverlap() {}
+
+PipelineColorBlendAdvancedStateCreateInfoEXT::PipelineColorBlendAdvancedStateCreateInfoEXT(
+    const PipelineColorBlendAdvancedStateCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    srcPremultiplied = copy_src.srcPremultiplied;
+    dstPremultiplied = copy_src.dstPremultiplied;
+    blendOverlap = copy_src.blendOverlap;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineColorBlendAdvancedStateCreateInfoEXT& PipelineColorBlendAdvancedStateCreateInfoEXT::operator=(
+    const PipelineColorBlendAdvancedStateCreateInfoEXT& 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;
+}
+
+PipelineColorBlendAdvancedStateCreateInfoEXT::~PipelineColorBlendAdvancedStateCreateInfoEXT() { FreePnextChain(pNext); }
+
+void PipelineColorBlendAdvancedStateCreateInfoEXT::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 PipelineColorBlendAdvancedStateCreateInfoEXT::initialize(const PipelineColorBlendAdvancedStateCreateInfoEXT* 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);
+}
+
+DrmFormatModifierPropertiesListEXT::DrmFormatModifierPropertiesListEXT(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);
+    }
+}
+
+DrmFormatModifierPropertiesListEXT::DrmFormatModifierPropertiesListEXT()
+    : sType(VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT),
+      pNext(nullptr),
+      drmFormatModifierCount(),
+      pDrmFormatModifierProperties(nullptr) {}
+
+DrmFormatModifierPropertiesListEXT::DrmFormatModifierPropertiesListEXT(const DrmFormatModifierPropertiesListEXT& 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);
+    }
+}
+
+DrmFormatModifierPropertiesListEXT& DrmFormatModifierPropertiesListEXT::operator=(
+    const DrmFormatModifierPropertiesListEXT& 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;
+}
+
+DrmFormatModifierPropertiesListEXT::~DrmFormatModifierPropertiesListEXT() {
+    if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties;
+    FreePnextChain(pNext);
+}
+
+void DrmFormatModifierPropertiesListEXT::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 DrmFormatModifierPropertiesListEXT::initialize(const DrmFormatModifierPropertiesListEXT* 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);
+    }
+}
+
+PhysicalDeviceImageDrmFormatModifierInfoEXT::PhysicalDeviceImageDrmFormatModifierInfoEXT(
+    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;
+    }
+}
+
+PhysicalDeviceImageDrmFormatModifierInfoEXT::PhysicalDeviceImageDrmFormatModifierInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT),
+      pNext(nullptr),
+      drmFormatModifier(),
+      sharingMode(),
+      queueFamilyIndexCount(),
+      pQueueFamilyIndices(nullptr) {}
+
+PhysicalDeviceImageDrmFormatModifierInfoEXT::PhysicalDeviceImageDrmFormatModifierInfoEXT(
+    const PhysicalDeviceImageDrmFormatModifierInfoEXT& 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;
+    }
+}
+
+PhysicalDeviceImageDrmFormatModifierInfoEXT& PhysicalDeviceImageDrmFormatModifierInfoEXT::operator=(
+    const PhysicalDeviceImageDrmFormatModifierInfoEXT& 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;
+}
+
+PhysicalDeviceImageDrmFormatModifierInfoEXT::~PhysicalDeviceImageDrmFormatModifierInfoEXT() {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceImageDrmFormatModifierInfoEXT::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 PhysicalDeviceImageDrmFormatModifierInfoEXT::initialize(const PhysicalDeviceImageDrmFormatModifierInfoEXT* 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;
+    }
+}
+
+ImageDrmFormatModifierListCreateInfoEXT::ImageDrmFormatModifierListCreateInfoEXT(
+    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);
+    }
+}
+
+ImageDrmFormatModifierListCreateInfoEXT::ImageDrmFormatModifierListCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT),
+      pNext(nullptr),
+      drmFormatModifierCount(),
+      pDrmFormatModifiers(nullptr) {}
+
+ImageDrmFormatModifierListCreateInfoEXT::ImageDrmFormatModifierListCreateInfoEXT(
+    const ImageDrmFormatModifierListCreateInfoEXT& 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);
+    }
+}
+
+ImageDrmFormatModifierListCreateInfoEXT& ImageDrmFormatModifierListCreateInfoEXT::operator=(
+    const ImageDrmFormatModifierListCreateInfoEXT& 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;
+}
+
+ImageDrmFormatModifierListCreateInfoEXT::~ImageDrmFormatModifierListCreateInfoEXT() {
+    if (pDrmFormatModifiers) delete[] pDrmFormatModifiers;
+    FreePnextChain(pNext);
+}
+
+void ImageDrmFormatModifierListCreateInfoEXT::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 ImageDrmFormatModifierListCreateInfoEXT::initialize(const ImageDrmFormatModifierListCreateInfoEXT* 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);
+    }
+}
+
+ImageDrmFormatModifierExplicitCreateInfoEXT::ImageDrmFormatModifierExplicitCreateInfoEXT(
+    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);
+    }
+}
+
+ImageDrmFormatModifierExplicitCreateInfoEXT::ImageDrmFormatModifierExplicitCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT),
+      pNext(nullptr),
+      drmFormatModifier(),
+      drmFormatModifierPlaneCount(),
+      pPlaneLayouts(nullptr) {}
+
+ImageDrmFormatModifierExplicitCreateInfoEXT::ImageDrmFormatModifierExplicitCreateInfoEXT(
+    const ImageDrmFormatModifierExplicitCreateInfoEXT& 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);
+    }
+}
+
+ImageDrmFormatModifierExplicitCreateInfoEXT& ImageDrmFormatModifierExplicitCreateInfoEXT::operator=(
+    const ImageDrmFormatModifierExplicitCreateInfoEXT& 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;
+}
+
+ImageDrmFormatModifierExplicitCreateInfoEXT::~ImageDrmFormatModifierExplicitCreateInfoEXT() {
+    if (pPlaneLayouts) delete[] pPlaneLayouts;
+    FreePnextChain(pNext);
+}
+
+void ImageDrmFormatModifierExplicitCreateInfoEXT::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 ImageDrmFormatModifierExplicitCreateInfoEXT::initialize(const ImageDrmFormatModifierExplicitCreateInfoEXT* 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);
+    }
+}
+
+ImageDrmFormatModifierPropertiesEXT::ImageDrmFormatModifierPropertiesEXT(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);
+    }
+}
+
+ImageDrmFormatModifierPropertiesEXT::ImageDrmFormatModifierPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT), pNext(nullptr), drmFormatModifier() {}
+
+ImageDrmFormatModifierPropertiesEXT::ImageDrmFormatModifierPropertiesEXT(const ImageDrmFormatModifierPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    drmFormatModifier = copy_src.drmFormatModifier;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageDrmFormatModifierPropertiesEXT& ImageDrmFormatModifierPropertiesEXT::operator=(
+    const ImageDrmFormatModifierPropertiesEXT& 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;
+}
+
+ImageDrmFormatModifierPropertiesEXT::~ImageDrmFormatModifierPropertiesEXT() { FreePnextChain(pNext); }
+
+void ImageDrmFormatModifierPropertiesEXT::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 ImageDrmFormatModifierPropertiesEXT::initialize(const ImageDrmFormatModifierPropertiesEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    drmFormatModifier = copy_src->drmFormatModifier;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DrmFormatModifierPropertiesList2EXT::DrmFormatModifierPropertiesList2EXT(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);
+    }
+}
+
+DrmFormatModifierPropertiesList2EXT::DrmFormatModifierPropertiesList2EXT()
+    : sType(VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT),
+      pNext(nullptr),
+      drmFormatModifierCount(),
+      pDrmFormatModifierProperties(nullptr) {}
+
+DrmFormatModifierPropertiesList2EXT::DrmFormatModifierPropertiesList2EXT(const DrmFormatModifierPropertiesList2EXT& 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);
+    }
+}
+
+DrmFormatModifierPropertiesList2EXT& DrmFormatModifierPropertiesList2EXT::operator=(
+    const DrmFormatModifierPropertiesList2EXT& 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;
+}
+
+DrmFormatModifierPropertiesList2EXT::~DrmFormatModifierPropertiesList2EXT() {
+    if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties;
+    FreePnextChain(pNext);
+}
+
+void DrmFormatModifierPropertiesList2EXT::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 DrmFormatModifierPropertiesList2EXT::initialize(const DrmFormatModifierPropertiesList2EXT* 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);
+    }
+}
+
+ValidationCacheCreateInfoEXT::ValidationCacheCreateInfoEXT(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);
+    }
+}
+
+ValidationCacheCreateInfoEXT::ValidationCacheCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      initialDataSize(),
+      pInitialData(nullptr) {}
+
+ValidationCacheCreateInfoEXT::ValidationCacheCreateInfoEXT(const ValidationCacheCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    initialDataSize = copy_src.initialDataSize;
+    pInitialData = copy_src.pInitialData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ValidationCacheCreateInfoEXT& ValidationCacheCreateInfoEXT::operator=(const ValidationCacheCreateInfoEXT& 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;
+}
+
+ValidationCacheCreateInfoEXT::~ValidationCacheCreateInfoEXT() { FreePnextChain(pNext); }
+
+void ValidationCacheCreateInfoEXT::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 ValidationCacheCreateInfoEXT::initialize(const ValidationCacheCreateInfoEXT* 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);
+}
+
+ShaderModuleValidationCacheCreateInfoEXT::ShaderModuleValidationCacheCreateInfoEXT(
+    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);
+    }
+}
+
+ShaderModuleValidationCacheCreateInfoEXT::ShaderModuleValidationCacheCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT), pNext(nullptr), validationCache() {}
+
+ShaderModuleValidationCacheCreateInfoEXT::ShaderModuleValidationCacheCreateInfoEXT(
+    const ShaderModuleValidationCacheCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    validationCache = copy_src.validationCache;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ShaderModuleValidationCacheCreateInfoEXT& ShaderModuleValidationCacheCreateInfoEXT::operator=(
+    const ShaderModuleValidationCacheCreateInfoEXT& 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;
+}
+
+ShaderModuleValidationCacheCreateInfoEXT::~ShaderModuleValidationCacheCreateInfoEXT() { FreePnextChain(pNext); }
+
+void ShaderModuleValidationCacheCreateInfoEXT::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 ShaderModuleValidationCacheCreateInfoEXT::initialize(const ShaderModuleValidationCacheCreateInfoEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    validationCache = copy_src->validationCache;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceImageViewImageFormatInfoEXT::PhysicalDeviceImageViewImageFormatInfoEXT(
+    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);
+    }
+}
+
+PhysicalDeviceImageViewImageFormatInfoEXT::PhysicalDeviceImageViewImageFormatInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT), pNext(nullptr), imageViewType() {}
+
+PhysicalDeviceImageViewImageFormatInfoEXT::PhysicalDeviceImageViewImageFormatInfoEXT(
+    const PhysicalDeviceImageViewImageFormatInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    imageViewType = copy_src.imageViewType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceImageViewImageFormatInfoEXT& PhysicalDeviceImageViewImageFormatInfoEXT::operator=(
+    const PhysicalDeviceImageViewImageFormatInfoEXT& 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;
+}
+
+PhysicalDeviceImageViewImageFormatInfoEXT::~PhysicalDeviceImageViewImageFormatInfoEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImageViewImageFormatInfoEXT::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 PhysicalDeviceImageViewImageFormatInfoEXT::initialize(const PhysicalDeviceImageViewImageFormatInfoEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageViewType = copy_src->imageViewType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+FilterCubicImageViewImageFormatPropertiesEXT::FilterCubicImageViewImageFormatPropertiesEXT(
+    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);
+    }
+}
+
+FilterCubicImageViewImageFormatPropertiesEXT::FilterCubicImageViewImageFormatPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT),
+      pNext(nullptr),
+      filterCubic(),
+      filterCubicMinmax() {}
+
+FilterCubicImageViewImageFormatPropertiesEXT::FilterCubicImageViewImageFormatPropertiesEXT(
+    const FilterCubicImageViewImageFormatPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    filterCubic = copy_src.filterCubic;
+    filterCubicMinmax = copy_src.filterCubicMinmax;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+FilterCubicImageViewImageFormatPropertiesEXT& FilterCubicImageViewImageFormatPropertiesEXT::operator=(
+    const FilterCubicImageViewImageFormatPropertiesEXT& 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;
+}
+
+FilterCubicImageViewImageFormatPropertiesEXT::~FilterCubicImageViewImageFormatPropertiesEXT() { FreePnextChain(pNext); }
+
+void FilterCubicImageViewImageFormatPropertiesEXT::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 FilterCubicImageViewImageFormatPropertiesEXT::initialize(const FilterCubicImageViewImageFormatPropertiesEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    filterCubic = copy_src->filterCubic;
+    filterCubicMinmax = copy_src->filterCubicMinmax;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImportMemoryHostPointerInfoEXT::ImportMemoryHostPointerInfoEXT(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);
+    }
+}
+
+ImportMemoryHostPointerInfoEXT::ImportMemoryHostPointerInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT), pNext(nullptr), handleType(), pHostPointer(nullptr) {}
+
+ImportMemoryHostPointerInfoEXT::ImportMemoryHostPointerInfoEXT(const ImportMemoryHostPointerInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pHostPointer = copy_src.pHostPointer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImportMemoryHostPointerInfoEXT& ImportMemoryHostPointerInfoEXT::operator=(const ImportMemoryHostPointerInfoEXT& 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;
+}
+
+ImportMemoryHostPointerInfoEXT::~ImportMemoryHostPointerInfoEXT() { FreePnextChain(pNext); }
+
+void ImportMemoryHostPointerInfoEXT::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 ImportMemoryHostPointerInfoEXT::initialize(const ImportMemoryHostPointerInfoEXT* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    pHostPointer = copy_src->pHostPointer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryHostPointerPropertiesEXT::MemoryHostPointerPropertiesEXT(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);
+    }
+}
+
+MemoryHostPointerPropertiesEXT::MemoryHostPointerPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT), pNext(nullptr), memoryTypeBits() {}
+
+MemoryHostPointerPropertiesEXT::MemoryHostPointerPropertiesEXT(const MemoryHostPointerPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryHostPointerPropertiesEXT& MemoryHostPointerPropertiesEXT::operator=(const MemoryHostPointerPropertiesEXT& 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;
+}
+
+MemoryHostPointerPropertiesEXT::~MemoryHostPointerPropertiesEXT() { FreePnextChain(pNext); }
+
+void MemoryHostPointerPropertiesEXT::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 MemoryHostPointerPropertiesEXT::initialize(const MemoryHostPointerPropertiesEXT* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceExternalMemoryHostPropertiesEXT::PhysicalDeviceExternalMemoryHostPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceExternalMemoryHostPropertiesEXT::PhysicalDeviceExternalMemoryHostPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT),
+      pNext(nullptr),
+      minImportedHostPointerAlignment() {}
+
+PhysicalDeviceExternalMemoryHostPropertiesEXT::PhysicalDeviceExternalMemoryHostPropertiesEXT(
+    const PhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    minImportedHostPointerAlignment = copy_src.minImportedHostPointerAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExternalMemoryHostPropertiesEXT& PhysicalDeviceExternalMemoryHostPropertiesEXT::operator=(
+    const PhysicalDeviceExternalMemoryHostPropertiesEXT& 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;
+}
+
+PhysicalDeviceExternalMemoryHostPropertiesEXT::~PhysicalDeviceExternalMemoryHostPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExternalMemoryHostPropertiesEXT::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 PhysicalDeviceExternalMemoryHostPropertiesEXT::initialize(const PhysicalDeviceExternalMemoryHostPropertiesEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minImportedHostPointerAlignment = copy_src->minImportedHostPointerAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceVertexAttributeDivisorPropertiesEXT::PhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceVertexAttributeDivisorPropertiesEXT::PhysicalDeviceVertexAttributeDivisorPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT), pNext(nullptr), maxVertexAttribDivisor() {}
+
+PhysicalDeviceVertexAttributeDivisorPropertiesEXT::PhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    const PhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceVertexAttributeDivisorPropertiesEXT& PhysicalDeviceVertexAttributeDivisorPropertiesEXT::operator=(
+    const PhysicalDeviceVertexAttributeDivisorPropertiesEXT& 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;
+}
+
+PhysicalDeviceVertexAttributeDivisorPropertiesEXT::~PhysicalDeviceVertexAttributeDivisorPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVertexAttributeDivisorPropertiesEXT::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 PhysicalDeviceVertexAttributeDivisorPropertiesEXT::initialize(
+    const PhysicalDeviceVertexAttributeDivisorPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePCIBusInfoPropertiesEXT::PhysicalDevicePCIBusInfoPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDevicePCIBusInfoPropertiesEXT::PhysicalDevicePCIBusInfoPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT),
+      pNext(nullptr),
+      pciDomain(),
+      pciBus(),
+      pciDevice(),
+      pciFunction() {}
+
+PhysicalDevicePCIBusInfoPropertiesEXT::PhysicalDevicePCIBusInfoPropertiesEXT(
+    const PhysicalDevicePCIBusInfoPropertiesEXT& 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);
+}
+
+PhysicalDevicePCIBusInfoPropertiesEXT& PhysicalDevicePCIBusInfoPropertiesEXT::operator=(
+    const PhysicalDevicePCIBusInfoPropertiesEXT& 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;
+}
+
+PhysicalDevicePCIBusInfoPropertiesEXT::~PhysicalDevicePCIBusInfoPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDevicePCIBusInfoPropertiesEXT::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 PhysicalDevicePCIBusInfoPropertiesEXT::initialize(const PhysicalDevicePCIBusInfoPropertiesEXT* 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);
+}
+
+PhysicalDeviceFragmentDensityMapFeaturesEXT::PhysicalDeviceFragmentDensityMapFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentDensityMapFeaturesEXT::PhysicalDeviceFragmentDensityMapFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT),
+      pNext(nullptr),
+      fragmentDensityMap(),
+      fragmentDensityMapDynamic(),
+      fragmentDensityMapNonSubsampledImages() {}
+
+PhysicalDeviceFragmentDensityMapFeaturesEXT::PhysicalDeviceFragmentDensityMapFeaturesEXT(
+    const PhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityMap = copy_src.fragmentDensityMap;
+    fragmentDensityMapDynamic = copy_src.fragmentDensityMapDynamic;
+    fragmentDensityMapNonSubsampledImages = copy_src.fragmentDensityMapNonSubsampledImages;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentDensityMapFeaturesEXT& PhysicalDeviceFragmentDensityMapFeaturesEXT::operator=(
+    const PhysicalDeviceFragmentDensityMapFeaturesEXT& 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;
+}
+
+PhysicalDeviceFragmentDensityMapFeaturesEXT::~PhysicalDeviceFragmentDensityMapFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentDensityMapFeaturesEXT::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 PhysicalDeviceFragmentDensityMapFeaturesEXT::initialize(const PhysicalDeviceFragmentDensityMapFeaturesEXT* 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);
+}
+
+PhysicalDeviceFragmentDensityMapPropertiesEXT::PhysicalDeviceFragmentDensityMapPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentDensityMapPropertiesEXT::PhysicalDeviceFragmentDensityMapPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT),
+      pNext(nullptr),
+      minFragmentDensityTexelSize(),
+      maxFragmentDensityTexelSize(),
+      fragmentDensityInvocations() {}
+
+PhysicalDeviceFragmentDensityMapPropertiesEXT::PhysicalDeviceFragmentDensityMapPropertiesEXT(
+    const PhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    minFragmentDensityTexelSize = copy_src.minFragmentDensityTexelSize;
+    maxFragmentDensityTexelSize = copy_src.maxFragmentDensityTexelSize;
+    fragmentDensityInvocations = copy_src.fragmentDensityInvocations;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentDensityMapPropertiesEXT& PhysicalDeviceFragmentDensityMapPropertiesEXT::operator=(
+    const PhysicalDeviceFragmentDensityMapPropertiesEXT& 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;
+}
+
+PhysicalDeviceFragmentDensityMapPropertiesEXT::~PhysicalDeviceFragmentDensityMapPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentDensityMapPropertiesEXT::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 PhysicalDeviceFragmentDensityMapPropertiesEXT::initialize(const PhysicalDeviceFragmentDensityMapPropertiesEXT* 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);
+}
+
+RenderPassFragmentDensityMapCreateInfoEXT::RenderPassFragmentDensityMapCreateInfoEXT(
+    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);
+    }
+}
+
+RenderPassFragmentDensityMapCreateInfoEXT::RenderPassFragmentDensityMapCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT), pNext(nullptr), fragmentDensityMapAttachment() {}
+
+RenderPassFragmentDensityMapCreateInfoEXT::RenderPassFragmentDensityMapCreateInfoEXT(
+    const RenderPassFragmentDensityMapCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityMapAttachment = copy_src.fragmentDensityMapAttachment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+RenderPassFragmentDensityMapCreateInfoEXT& RenderPassFragmentDensityMapCreateInfoEXT::operator=(
+    const RenderPassFragmentDensityMapCreateInfoEXT& 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;
+}
+
+RenderPassFragmentDensityMapCreateInfoEXT::~RenderPassFragmentDensityMapCreateInfoEXT() { FreePnextChain(pNext); }
+
+void RenderPassFragmentDensityMapCreateInfoEXT::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 RenderPassFragmentDensityMapCreateInfoEXT::initialize(const RenderPassFragmentDensityMapCreateInfoEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityMapAttachment = copy_src->fragmentDensityMapAttachment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderImageAtomicInt64FeaturesEXT::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceShaderImageAtomicInt64FeaturesEXT::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT),
+      pNext(nullptr),
+      shaderImageInt64Atomics(),
+      sparseImageInt64Atomics() {}
+
+PhysicalDeviceShaderImageAtomicInt64FeaturesEXT::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+    const PhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderImageInt64Atomics = copy_src.shaderImageInt64Atomics;
+    sparseImageInt64Atomics = copy_src.sparseImageInt64Atomics;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderImageAtomicInt64FeaturesEXT& PhysicalDeviceShaderImageAtomicInt64FeaturesEXT::operator=(
+    const PhysicalDeviceShaderImageAtomicInt64FeaturesEXT& 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;
+}
+
+PhysicalDeviceShaderImageAtomicInt64FeaturesEXT::~PhysicalDeviceShaderImageAtomicInt64FeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderImageAtomicInt64FeaturesEXT::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 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT::initialize(const PhysicalDeviceShaderImageAtomicInt64FeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderImageInt64Atomics = copy_src->shaderImageInt64Atomics;
+    sparseImageInt64Atomics = copy_src->sparseImageInt64Atomics;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMemoryBudgetPropertiesEXT::PhysicalDeviceMemoryBudgetPropertiesEXT(
+    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];
+    }
+}
+
+PhysicalDeviceMemoryBudgetPropertiesEXT::PhysicalDeviceMemoryBudgetPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT), pNext(nullptr) {}
+
+PhysicalDeviceMemoryBudgetPropertiesEXT::PhysicalDeviceMemoryBudgetPropertiesEXT(
+    const PhysicalDeviceMemoryBudgetPropertiesEXT& 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];
+    }
+}
+
+PhysicalDeviceMemoryBudgetPropertiesEXT& PhysicalDeviceMemoryBudgetPropertiesEXT::operator=(
+    const PhysicalDeviceMemoryBudgetPropertiesEXT& 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;
+}
+
+PhysicalDeviceMemoryBudgetPropertiesEXT::~PhysicalDeviceMemoryBudgetPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMemoryBudgetPropertiesEXT::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 PhysicalDeviceMemoryBudgetPropertiesEXT::initialize(const PhysicalDeviceMemoryBudgetPropertiesEXT* 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];
+    }
+}
+
+PhysicalDeviceMemoryPriorityFeaturesEXT::PhysicalDeviceMemoryPriorityFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceMemoryPriorityFeaturesEXT::PhysicalDeviceMemoryPriorityFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT), pNext(nullptr), memoryPriority() {}
+
+PhysicalDeviceMemoryPriorityFeaturesEXT::PhysicalDeviceMemoryPriorityFeaturesEXT(
+    const PhysicalDeviceMemoryPriorityFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    memoryPriority = copy_src.memoryPriority;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMemoryPriorityFeaturesEXT& PhysicalDeviceMemoryPriorityFeaturesEXT::operator=(
+    const PhysicalDeviceMemoryPriorityFeaturesEXT& 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;
+}
+
+PhysicalDeviceMemoryPriorityFeaturesEXT::~PhysicalDeviceMemoryPriorityFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMemoryPriorityFeaturesEXT::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 PhysicalDeviceMemoryPriorityFeaturesEXT::initialize(const PhysicalDeviceMemoryPriorityFeaturesEXT* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryPriority = copy_src->memoryPriority;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryPriorityAllocateInfoEXT::MemoryPriorityAllocateInfoEXT(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);
+    }
+}
+
+MemoryPriorityAllocateInfoEXT::MemoryPriorityAllocateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT), pNext(nullptr), priority() {}
+
+MemoryPriorityAllocateInfoEXT::MemoryPriorityAllocateInfoEXT(const MemoryPriorityAllocateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    priority = copy_src.priority;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryPriorityAllocateInfoEXT& MemoryPriorityAllocateInfoEXT::operator=(const MemoryPriorityAllocateInfoEXT& 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;
+}
+
+MemoryPriorityAllocateInfoEXT::~MemoryPriorityAllocateInfoEXT() { FreePnextChain(pNext); }
+
+void MemoryPriorityAllocateInfoEXT::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 MemoryPriorityAllocateInfoEXT::initialize(const MemoryPriorityAllocateInfoEXT* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    priority = copy_src->priority;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceBufferDeviceAddressFeaturesEXT::PhysicalDeviceBufferDeviceAddressFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceBufferDeviceAddressFeaturesEXT::PhysicalDeviceBufferDeviceAddressFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT),
+      pNext(nullptr),
+      bufferDeviceAddress(),
+      bufferDeviceAddressCaptureReplay(),
+      bufferDeviceAddressMultiDevice() {}
+
+PhysicalDeviceBufferDeviceAddressFeaturesEXT::PhysicalDeviceBufferDeviceAddressFeaturesEXT(
+    const PhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    bufferDeviceAddress = copy_src.bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceBufferDeviceAddressFeaturesEXT& PhysicalDeviceBufferDeviceAddressFeaturesEXT::operator=(
+    const PhysicalDeviceBufferDeviceAddressFeaturesEXT& 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;
+}
+
+PhysicalDeviceBufferDeviceAddressFeaturesEXT::~PhysicalDeviceBufferDeviceAddressFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceBufferDeviceAddressFeaturesEXT::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 PhysicalDeviceBufferDeviceAddressFeaturesEXT::initialize(const PhysicalDeviceBufferDeviceAddressFeaturesEXT* 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);
+}
+
+BufferDeviceAddressCreateInfoEXT::BufferDeviceAddressCreateInfoEXT(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);
+    }
+}
+
+BufferDeviceAddressCreateInfoEXT::BufferDeviceAddressCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT), pNext(nullptr), deviceAddress() {}
+
+BufferDeviceAddressCreateInfoEXT::BufferDeviceAddressCreateInfoEXT(const BufferDeviceAddressCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    deviceAddress = copy_src.deviceAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BufferDeviceAddressCreateInfoEXT& BufferDeviceAddressCreateInfoEXT::operator=(const BufferDeviceAddressCreateInfoEXT& 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;
+}
+
+BufferDeviceAddressCreateInfoEXT::~BufferDeviceAddressCreateInfoEXT() { FreePnextChain(pNext); }
+
+void BufferDeviceAddressCreateInfoEXT::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 BufferDeviceAddressCreateInfoEXT::initialize(const BufferDeviceAddressCreateInfoEXT* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceAddress = copy_src->deviceAddress;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ValidationFeaturesEXT::ValidationFeaturesEXT(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);
+    }
+}
+
+ValidationFeaturesEXT::ValidationFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT),
+      pNext(nullptr),
+      enabledValidationFeatureCount(),
+      pEnabledValidationFeatures(nullptr),
+      disabledValidationFeatureCount(),
+      pDisabledValidationFeatures(nullptr) {}
+
+ValidationFeaturesEXT::ValidationFeaturesEXT(const ValidationFeaturesEXT& 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);
+    }
+}
+
+ValidationFeaturesEXT& ValidationFeaturesEXT::operator=(const ValidationFeaturesEXT& 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;
+}
+
+ValidationFeaturesEXT::~ValidationFeaturesEXT() {
+    if (pEnabledValidationFeatures) delete[] pEnabledValidationFeatures;
+    if (pDisabledValidationFeatures) delete[] pDisabledValidationFeatures;
+    FreePnextChain(pNext);
+}
+
+void ValidationFeaturesEXT::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 ValidationFeaturesEXT::initialize(const ValidationFeaturesEXT* 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);
+    }
+}
+
+PhysicalDeviceFragmentShaderInterlockFeaturesEXT::PhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentShaderInterlockFeaturesEXT::PhysicalDeviceFragmentShaderInterlockFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT),
+      pNext(nullptr),
+      fragmentShaderSampleInterlock(),
+      fragmentShaderPixelInterlock(),
+      fragmentShaderShadingRateInterlock() {}
+
+PhysicalDeviceFragmentShaderInterlockFeaturesEXT::PhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+    const PhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    fragmentShaderSampleInterlock = copy_src.fragmentShaderSampleInterlock;
+    fragmentShaderPixelInterlock = copy_src.fragmentShaderPixelInterlock;
+    fragmentShaderShadingRateInterlock = copy_src.fragmentShaderShadingRateInterlock;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentShaderInterlockFeaturesEXT& PhysicalDeviceFragmentShaderInterlockFeaturesEXT::operator=(
+    const PhysicalDeviceFragmentShaderInterlockFeaturesEXT& 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;
+}
+
+PhysicalDeviceFragmentShaderInterlockFeaturesEXT::~PhysicalDeviceFragmentShaderInterlockFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentShaderInterlockFeaturesEXT::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 PhysicalDeviceFragmentShaderInterlockFeaturesEXT::initialize(const PhysicalDeviceFragmentShaderInterlockFeaturesEXT* 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);
+}
+
+PhysicalDeviceYcbcrImageArraysFeaturesEXT::PhysicalDeviceYcbcrImageArraysFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceYcbcrImageArraysFeaturesEXT::PhysicalDeviceYcbcrImageArraysFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT), pNext(nullptr), ycbcrImageArrays() {}
+
+PhysicalDeviceYcbcrImageArraysFeaturesEXT::PhysicalDeviceYcbcrImageArraysFeaturesEXT(
+    const PhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    ycbcrImageArrays = copy_src.ycbcrImageArrays;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceYcbcrImageArraysFeaturesEXT& PhysicalDeviceYcbcrImageArraysFeaturesEXT::operator=(
+    const PhysicalDeviceYcbcrImageArraysFeaturesEXT& 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;
+}
+
+PhysicalDeviceYcbcrImageArraysFeaturesEXT::~PhysicalDeviceYcbcrImageArraysFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceYcbcrImageArraysFeaturesEXT::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 PhysicalDeviceYcbcrImageArraysFeaturesEXT::initialize(const PhysicalDeviceYcbcrImageArraysFeaturesEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    ycbcrImageArrays = copy_src->ycbcrImageArrays;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceProvokingVertexFeaturesEXT::PhysicalDeviceProvokingVertexFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceProvokingVertexFeaturesEXT::PhysicalDeviceProvokingVertexFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT),
+      pNext(nullptr),
+      provokingVertexLast(),
+      transformFeedbackPreservesProvokingVertex() {}
+
+PhysicalDeviceProvokingVertexFeaturesEXT::PhysicalDeviceProvokingVertexFeaturesEXT(
+    const PhysicalDeviceProvokingVertexFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    provokingVertexLast = copy_src.provokingVertexLast;
+    transformFeedbackPreservesProvokingVertex = copy_src.transformFeedbackPreservesProvokingVertex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceProvokingVertexFeaturesEXT& PhysicalDeviceProvokingVertexFeaturesEXT::operator=(
+    const PhysicalDeviceProvokingVertexFeaturesEXT& 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;
+}
+
+PhysicalDeviceProvokingVertexFeaturesEXT::~PhysicalDeviceProvokingVertexFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceProvokingVertexFeaturesEXT::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 PhysicalDeviceProvokingVertexFeaturesEXT::initialize(const PhysicalDeviceProvokingVertexFeaturesEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    provokingVertexLast = copy_src->provokingVertexLast;
+    transformFeedbackPreservesProvokingVertex = copy_src->transformFeedbackPreservesProvokingVertex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceProvokingVertexPropertiesEXT::PhysicalDeviceProvokingVertexPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceProvokingVertexPropertiesEXT::PhysicalDeviceProvokingVertexPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT),
+      pNext(nullptr),
+      provokingVertexModePerPipeline(),
+      transformFeedbackPreservesTriangleFanProvokingVertex() {}
+
+PhysicalDeviceProvokingVertexPropertiesEXT::PhysicalDeviceProvokingVertexPropertiesEXT(
+    const PhysicalDeviceProvokingVertexPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    provokingVertexModePerPipeline = copy_src.provokingVertexModePerPipeline;
+    transformFeedbackPreservesTriangleFanProvokingVertex = copy_src.transformFeedbackPreservesTriangleFanProvokingVertex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceProvokingVertexPropertiesEXT& PhysicalDeviceProvokingVertexPropertiesEXT::operator=(
+    const PhysicalDeviceProvokingVertexPropertiesEXT& 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;
+}
+
+PhysicalDeviceProvokingVertexPropertiesEXT::~PhysicalDeviceProvokingVertexPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceProvokingVertexPropertiesEXT::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 PhysicalDeviceProvokingVertexPropertiesEXT::initialize(const PhysicalDeviceProvokingVertexPropertiesEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    provokingVertexModePerPipeline = copy_src->provokingVertexModePerPipeline;
+    transformFeedbackPreservesTriangleFanProvokingVertex = copy_src->transformFeedbackPreservesTriangleFanProvokingVertex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineRasterizationProvokingVertexStateCreateInfoEXT::PipelineRasterizationProvokingVertexStateCreateInfoEXT(
+    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);
+    }
+}
+
+PipelineRasterizationProvokingVertexStateCreateInfoEXT::PipelineRasterizationProvokingVertexStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      provokingVertexMode() {}
+
+PipelineRasterizationProvokingVertexStateCreateInfoEXT::PipelineRasterizationProvokingVertexStateCreateInfoEXT(
+    const PipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    provokingVertexMode = copy_src.provokingVertexMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineRasterizationProvokingVertexStateCreateInfoEXT& PipelineRasterizationProvokingVertexStateCreateInfoEXT::operator=(
+    const PipelineRasterizationProvokingVertexStateCreateInfoEXT& 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;
+}
+
+PipelineRasterizationProvokingVertexStateCreateInfoEXT::~PipelineRasterizationProvokingVertexStateCreateInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void PipelineRasterizationProvokingVertexStateCreateInfoEXT::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 PipelineRasterizationProvokingVertexStateCreateInfoEXT::initialize(
+    const PipelineRasterizationProvokingVertexStateCreateInfoEXT* 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
+
+SurfaceFullScreenExclusiveInfoEXT::SurfaceFullScreenExclusiveInfoEXT(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);
+    }
+}
+
+SurfaceFullScreenExclusiveInfoEXT::SurfaceFullScreenExclusiveInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT), pNext(nullptr), fullScreenExclusive() {}
+
+SurfaceFullScreenExclusiveInfoEXT::SurfaceFullScreenExclusiveInfoEXT(const SurfaceFullScreenExclusiveInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    fullScreenExclusive = copy_src.fullScreenExclusive;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SurfaceFullScreenExclusiveInfoEXT& SurfaceFullScreenExclusiveInfoEXT::operator=(const SurfaceFullScreenExclusiveInfoEXT& 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;
+}
+
+SurfaceFullScreenExclusiveInfoEXT::~SurfaceFullScreenExclusiveInfoEXT() { FreePnextChain(pNext); }
+
+void SurfaceFullScreenExclusiveInfoEXT::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 SurfaceFullScreenExclusiveInfoEXT::initialize(const SurfaceFullScreenExclusiveInfoEXT* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fullScreenExclusive = copy_src->fullScreenExclusive;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SurfaceCapabilitiesFullScreenExclusiveEXT::SurfaceCapabilitiesFullScreenExclusiveEXT(
+    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);
+    }
+}
+
+SurfaceCapabilitiesFullScreenExclusiveEXT::SurfaceCapabilitiesFullScreenExclusiveEXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT), pNext(nullptr), fullScreenExclusiveSupported() {}
+
+SurfaceCapabilitiesFullScreenExclusiveEXT::SurfaceCapabilitiesFullScreenExclusiveEXT(
+    const SurfaceCapabilitiesFullScreenExclusiveEXT& copy_src) {
+    sType = copy_src.sType;
+    fullScreenExclusiveSupported = copy_src.fullScreenExclusiveSupported;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SurfaceCapabilitiesFullScreenExclusiveEXT& SurfaceCapabilitiesFullScreenExclusiveEXT::operator=(
+    const SurfaceCapabilitiesFullScreenExclusiveEXT& 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;
+}
+
+SurfaceCapabilitiesFullScreenExclusiveEXT::~SurfaceCapabilitiesFullScreenExclusiveEXT() { FreePnextChain(pNext); }
+
+void SurfaceCapabilitiesFullScreenExclusiveEXT::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 SurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const SurfaceCapabilitiesFullScreenExclusiveEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fullScreenExclusiveSupported = copy_src->fullScreenExclusiveSupported;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SurfaceFullScreenExclusiveWin32InfoEXT::SurfaceFullScreenExclusiveWin32InfoEXT(
+    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);
+    }
+}
+
+SurfaceFullScreenExclusiveWin32InfoEXT::SurfaceFullScreenExclusiveWin32InfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT), pNext(nullptr), hmonitor() {}
+
+SurfaceFullScreenExclusiveWin32InfoEXT::SurfaceFullScreenExclusiveWin32InfoEXT(
+    const SurfaceFullScreenExclusiveWin32InfoEXT& copy_src) {
+    sType = copy_src.sType;
+    hmonitor = copy_src.hmonitor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SurfaceFullScreenExclusiveWin32InfoEXT& SurfaceFullScreenExclusiveWin32InfoEXT::operator=(
+    const SurfaceFullScreenExclusiveWin32InfoEXT& 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;
+}
+
+SurfaceFullScreenExclusiveWin32InfoEXT::~SurfaceFullScreenExclusiveWin32InfoEXT() { FreePnextChain(pNext); }
+
+void SurfaceFullScreenExclusiveWin32InfoEXT::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 SurfaceFullScreenExclusiveWin32InfoEXT::initialize(const SurfaceFullScreenExclusiveWin32InfoEXT* 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
+
+HeadlessSurfaceCreateInfoEXT::HeadlessSurfaceCreateInfoEXT(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);
+    }
+}
+
+HeadlessSurfaceCreateInfoEXT::HeadlessSurfaceCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT), pNext(nullptr), flags() {}
+
+HeadlessSurfaceCreateInfoEXT::HeadlessSurfaceCreateInfoEXT(const HeadlessSurfaceCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+HeadlessSurfaceCreateInfoEXT& HeadlessSurfaceCreateInfoEXT::operator=(const HeadlessSurfaceCreateInfoEXT& 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;
+}
+
+HeadlessSurfaceCreateInfoEXT::~HeadlessSurfaceCreateInfoEXT() { FreePnextChain(pNext); }
+
+void HeadlessSurfaceCreateInfoEXT::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 HeadlessSurfaceCreateInfoEXT::initialize(const HeadlessSurfaceCreateInfoEXT* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderAtomicFloatFeaturesEXT::PhysicalDeviceShaderAtomicFloatFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceShaderAtomicFloatFeaturesEXT::PhysicalDeviceShaderAtomicFloatFeaturesEXT()
+    : 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() {}
+
+PhysicalDeviceShaderAtomicFloatFeaturesEXT::PhysicalDeviceShaderAtomicFloatFeaturesEXT(
+    const PhysicalDeviceShaderAtomicFloatFeaturesEXT& 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);
+}
+
+PhysicalDeviceShaderAtomicFloatFeaturesEXT& PhysicalDeviceShaderAtomicFloatFeaturesEXT::operator=(
+    const PhysicalDeviceShaderAtomicFloatFeaturesEXT& 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;
+}
+
+PhysicalDeviceShaderAtomicFloatFeaturesEXT::~PhysicalDeviceShaderAtomicFloatFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderAtomicFloatFeaturesEXT::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 PhysicalDeviceShaderAtomicFloatFeaturesEXT::initialize(const PhysicalDeviceShaderAtomicFloatFeaturesEXT* 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);
+}
+
+PhysicalDeviceExtendedDynamicStateFeaturesEXT::PhysicalDeviceExtendedDynamicStateFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceExtendedDynamicStateFeaturesEXT::PhysicalDeviceExtendedDynamicStateFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT), pNext(nullptr), extendedDynamicState() {}
+
+PhysicalDeviceExtendedDynamicStateFeaturesEXT::PhysicalDeviceExtendedDynamicStateFeaturesEXT(
+    const PhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    extendedDynamicState = copy_src.extendedDynamicState;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExtendedDynamicStateFeaturesEXT& PhysicalDeviceExtendedDynamicStateFeaturesEXT::operator=(
+    const PhysicalDeviceExtendedDynamicStateFeaturesEXT& 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;
+}
+
+PhysicalDeviceExtendedDynamicStateFeaturesEXT::~PhysicalDeviceExtendedDynamicStateFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExtendedDynamicStateFeaturesEXT::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 PhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize(const PhysicalDeviceExtendedDynamicStateFeaturesEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    extendedDynamicState = copy_src->extendedDynamicState;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceHostImageCopyFeaturesEXT::PhysicalDeviceHostImageCopyFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceHostImageCopyFeaturesEXT::PhysicalDeviceHostImageCopyFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT), pNext(nullptr), hostImageCopy() {}
+
+PhysicalDeviceHostImageCopyFeaturesEXT::PhysicalDeviceHostImageCopyFeaturesEXT(
+    const PhysicalDeviceHostImageCopyFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    hostImageCopy = copy_src.hostImageCopy;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceHostImageCopyFeaturesEXT& PhysicalDeviceHostImageCopyFeaturesEXT::operator=(
+    const PhysicalDeviceHostImageCopyFeaturesEXT& 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;
+}
+
+PhysicalDeviceHostImageCopyFeaturesEXT::~PhysicalDeviceHostImageCopyFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceHostImageCopyFeaturesEXT::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 PhysicalDeviceHostImageCopyFeaturesEXT::initialize(const PhysicalDeviceHostImageCopyFeaturesEXT* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hostImageCopy = copy_src->hostImageCopy;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceHostImageCopyPropertiesEXT::PhysicalDeviceHostImageCopyPropertiesEXT(
+    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];
+    }
+}
+
+PhysicalDeviceHostImageCopyPropertiesEXT::PhysicalDeviceHostImageCopyPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT),
+      pNext(nullptr),
+      copySrcLayoutCount(),
+      pCopySrcLayouts(nullptr),
+      copyDstLayoutCount(),
+      pCopyDstLayouts(nullptr),
+      identicalMemoryTypeRequirements() {}
+
+PhysicalDeviceHostImageCopyPropertiesEXT::PhysicalDeviceHostImageCopyPropertiesEXT(
+    const PhysicalDeviceHostImageCopyPropertiesEXT& 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];
+    }
+}
+
+PhysicalDeviceHostImageCopyPropertiesEXT& PhysicalDeviceHostImageCopyPropertiesEXT::operator=(
+    const PhysicalDeviceHostImageCopyPropertiesEXT& 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;
+}
+
+PhysicalDeviceHostImageCopyPropertiesEXT::~PhysicalDeviceHostImageCopyPropertiesEXT() {
+    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
+    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceHostImageCopyPropertiesEXT::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 PhysicalDeviceHostImageCopyPropertiesEXT::initialize(const PhysicalDeviceHostImageCopyPropertiesEXT* 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];
+    }
+}
+
+MemoryToImageCopyEXT::MemoryToImageCopyEXT(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);
+    }
+}
+
+MemoryToImageCopyEXT::MemoryToImageCopyEXT()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT),
+      pNext(nullptr),
+      pHostPointer(nullptr),
+      memoryRowLength(),
+      memoryImageHeight(),
+      imageSubresource(),
+      imageOffset(),
+      imageExtent() {}
+
+MemoryToImageCopyEXT::MemoryToImageCopyEXT(const MemoryToImageCopyEXT& 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);
+}
+
+MemoryToImageCopyEXT& MemoryToImageCopyEXT::operator=(const MemoryToImageCopyEXT& 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;
+}
+
+MemoryToImageCopyEXT::~MemoryToImageCopyEXT() { FreePnextChain(pNext); }
+
+void MemoryToImageCopyEXT::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 MemoryToImageCopyEXT::initialize(const MemoryToImageCopyEXT* 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);
+}
+
+ImageToMemoryCopyEXT::ImageToMemoryCopyEXT(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);
+    }
+}
+
+ImageToMemoryCopyEXT::ImageToMemoryCopyEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT),
+      pNext(nullptr),
+      pHostPointer(nullptr),
+      memoryRowLength(),
+      memoryImageHeight(),
+      imageSubresource(),
+      imageOffset(),
+      imageExtent() {}
+
+ImageToMemoryCopyEXT::ImageToMemoryCopyEXT(const ImageToMemoryCopyEXT& 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);
+}
+
+ImageToMemoryCopyEXT& ImageToMemoryCopyEXT::operator=(const ImageToMemoryCopyEXT& 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;
+}
+
+ImageToMemoryCopyEXT::~ImageToMemoryCopyEXT() { FreePnextChain(pNext); }
+
+void ImageToMemoryCopyEXT::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 ImageToMemoryCopyEXT::initialize(const ImageToMemoryCopyEXT* 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);
+}
+
+CopyMemoryToImageInfoEXT::CopyMemoryToImageInfoEXT(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 MemoryToImageCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+CopyMemoryToImageInfoEXT::CopyMemoryToImageInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+CopyMemoryToImageInfoEXT::CopyMemoryToImageInfoEXT(const CopyMemoryToImageInfoEXT& 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 MemoryToImageCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+CopyMemoryToImageInfoEXT& CopyMemoryToImageInfoEXT::operator=(const CopyMemoryToImageInfoEXT& 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 MemoryToImageCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+CopyMemoryToImageInfoEXT::~CopyMemoryToImageInfoEXT() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void CopyMemoryToImageInfoEXT::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 MemoryToImageCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void CopyMemoryToImageInfoEXT::initialize(const CopyMemoryToImageInfoEXT* 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 MemoryToImageCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+CopyImageToMemoryInfoEXT::CopyImageToMemoryInfoEXT(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 ImageToMemoryCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+CopyImageToMemoryInfoEXT::CopyImageToMemoryInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      srcImage(),
+      srcImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+CopyImageToMemoryInfoEXT::CopyImageToMemoryInfoEXT(const CopyImageToMemoryInfoEXT& 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 ImageToMemoryCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+CopyImageToMemoryInfoEXT& CopyImageToMemoryInfoEXT::operator=(const CopyImageToMemoryInfoEXT& 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 ImageToMemoryCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+CopyImageToMemoryInfoEXT::~CopyImageToMemoryInfoEXT() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void CopyImageToMemoryInfoEXT::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 ImageToMemoryCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void CopyImageToMemoryInfoEXT::initialize(const CopyImageToMemoryInfoEXT* 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 ImageToMemoryCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+CopyImageToImageInfoEXT::CopyImageToImageInfoEXT(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 ImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+CopyImageToImageInfoEXT::CopyImageToImageInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      srcImage(),
+      srcImageLayout(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+CopyImageToImageInfoEXT::CopyImageToImageInfoEXT(const CopyImageToImageInfoEXT& 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 ImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+CopyImageToImageInfoEXT& CopyImageToImageInfoEXT::operator=(const CopyImageToImageInfoEXT& 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 ImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+CopyImageToImageInfoEXT::~CopyImageToImageInfoEXT() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void CopyImageToImageInfoEXT::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 ImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void CopyImageToImageInfoEXT::initialize(const CopyImageToImageInfoEXT* 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 ImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+HostImageLayoutTransitionInfoEXT::HostImageLayoutTransitionInfoEXT(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);
+    }
+}
+
+HostImageLayoutTransitionInfoEXT::HostImageLayoutTransitionInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT),
+      pNext(nullptr),
+      image(),
+      oldLayout(),
+      newLayout(),
+      subresourceRange() {}
+
+HostImageLayoutTransitionInfoEXT::HostImageLayoutTransitionInfoEXT(const HostImageLayoutTransitionInfoEXT& 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);
+}
+
+HostImageLayoutTransitionInfoEXT& HostImageLayoutTransitionInfoEXT::operator=(const HostImageLayoutTransitionInfoEXT& 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;
+}
+
+HostImageLayoutTransitionInfoEXT::~HostImageLayoutTransitionInfoEXT() { FreePnextChain(pNext); }
+
+void HostImageLayoutTransitionInfoEXT::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 HostImageLayoutTransitionInfoEXT::initialize(const HostImageLayoutTransitionInfoEXT* 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);
+}
+
+SubresourceHostMemcpySizeEXT::SubresourceHostMemcpySizeEXT(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);
+    }
+}
+
+SubresourceHostMemcpySizeEXT::SubresourceHostMemcpySizeEXT()
+    : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT), pNext(nullptr), size() {}
+
+SubresourceHostMemcpySizeEXT::SubresourceHostMemcpySizeEXT(const SubresourceHostMemcpySizeEXT& copy_src) {
+    sType = copy_src.sType;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SubresourceHostMemcpySizeEXT& SubresourceHostMemcpySizeEXT::operator=(const SubresourceHostMemcpySizeEXT& 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;
+}
+
+SubresourceHostMemcpySizeEXT::~SubresourceHostMemcpySizeEXT() { FreePnextChain(pNext); }
+
+void SubresourceHostMemcpySizeEXT::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 SubresourceHostMemcpySizeEXT::initialize(const SubresourceHostMemcpySizeEXT* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+HostImageCopyDevicePerformanceQueryEXT::HostImageCopyDevicePerformanceQueryEXT(
+    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);
+    }
+}
+
+HostImageCopyDevicePerformanceQueryEXT::HostImageCopyDevicePerformanceQueryEXT()
+    : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT),
+      pNext(nullptr),
+      optimalDeviceAccess(),
+      identicalMemoryLayout() {}
+
+HostImageCopyDevicePerformanceQueryEXT::HostImageCopyDevicePerformanceQueryEXT(
+    const HostImageCopyDevicePerformanceQueryEXT& copy_src) {
+    sType = copy_src.sType;
+    optimalDeviceAccess = copy_src.optimalDeviceAccess;
+    identicalMemoryLayout = copy_src.identicalMemoryLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+HostImageCopyDevicePerformanceQueryEXT& HostImageCopyDevicePerformanceQueryEXT::operator=(
+    const HostImageCopyDevicePerformanceQueryEXT& 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;
+}
+
+HostImageCopyDevicePerformanceQueryEXT::~HostImageCopyDevicePerformanceQueryEXT() { FreePnextChain(pNext); }
+
+void HostImageCopyDevicePerformanceQueryEXT::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 HostImageCopyDevicePerformanceQueryEXT::initialize(const HostImageCopyDevicePerformanceQueryEXT* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    optimalDeviceAccess = copy_src->optimalDeviceAccess;
+    identicalMemoryLayout = copy_src->identicalMemoryLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMapMemoryPlacedFeaturesEXT::PhysicalDeviceMapMemoryPlacedFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceMapMemoryPlacedFeaturesEXT::PhysicalDeviceMapMemoryPlacedFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT),
+      pNext(nullptr),
+      memoryMapPlaced(),
+      memoryMapRangePlaced(),
+      memoryUnmapReserve() {}
+
+PhysicalDeviceMapMemoryPlacedFeaturesEXT::PhysicalDeviceMapMemoryPlacedFeaturesEXT(
+    const PhysicalDeviceMapMemoryPlacedFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    memoryMapPlaced = copy_src.memoryMapPlaced;
+    memoryMapRangePlaced = copy_src.memoryMapRangePlaced;
+    memoryUnmapReserve = copy_src.memoryUnmapReserve;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMapMemoryPlacedFeaturesEXT& PhysicalDeviceMapMemoryPlacedFeaturesEXT::operator=(
+    const PhysicalDeviceMapMemoryPlacedFeaturesEXT& 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;
+}
+
+PhysicalDeviceMapMemoryPlacedFeaturesEXT::~PhysicalDeviceMapMemoryPlacedFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMapMemoryPlacedFeaturesEXT::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 PhysicalDeviceMapMemoryPlacedFeaturesEXT::initialize(const PhysicalDeviceMapMemoryPlacedFeaturesEXT* 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);
+}
+
+PhysicalDeviceMapMemoryPlacedPropertiesEXT::PhysicalDeviceMapMemoryPlacedPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceMapMemoryPlacedPropertiesEXT::PhysicalDeviceMapMemoryPlacedPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT), pNext(nullptr), minPlacedMemoryMapAlignment() {}
+
+PhysicalDeviceMapMemoryPlacedPropertiesEXT::PhysicalDeviceMapMemoryPlacedPropertiesEXT(
+    const PhysicalDeviceMapMemoryPlacedPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    minPlacedMemoryMapAlignment = copy_src.minPlacedMemoryMapAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMapMemoryPlacedPropertiesEXT& PhysicalDeviceMapMemoryPlacedPropertiesEXT::operator=(
+    const PhysicalDeviceMapMemoryPlacedPropertiesEXT& 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;
+}
+
+PhysicalDeviceMapMemoryPlacedPropertiesEXT::~PhysicalDeviceMapMemoryPlacedPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMapMemoryPlacedPropertiesEXT::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 PhysicalDeviceMapMemoryPlacedPropertiesEXT::initialize(const PhysicalDeviceMapMemoryPlacedPropertiesEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minPlacedMemoryMapAlignment = copy_src->minPlacedMemoryMapAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryMapPlacedInfoEXT::MemoryMapPlacedInfoEXT(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);
+    }
+}
+
+MemoryMapPlacedInfoEXT::MemoryMapPlacedInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT), pNext(nullptr), pPlacedAddress(nullptr) {}
+
+MemoryMapPlacedInfoEXT::MemoryMapPlacedInfoEXT(const MemoryMapPlacedInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pPlacedAddress = copy_src.pPlacedAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryMapPlacedInfoEXT& MemoryMapPlacedInfoEXT::operator=(const MemoryMapPlacedInfoEXT& 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;
+}
+
+MemoryMapPlacedInfoEXT::~MemoryMapPlacedInfoEXT() { FreePnextChain(pNext); }
+
+void MemoryMapPlacedInfoEXT::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 MemoryMapPlacedInfoEXT::initialize(const MemoryMapPlacedInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pPlacedAddress = copy_src->pPlacedAddress;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderAtomicFloat2FeaturesEXT::PhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceShaderAtomicFloat2FeaturesEXT::PhysicalDeviceShaderAtomicFloat2FeaturesEXT()
+    : 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() {}
+
+PhysicalDeviceShaderAtomicFloat2FeaturesEXT::PhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+    const PhysicalDeviceShaderAtomicFloat2FeaturesEXT& 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);
+}
+
+PhysicalDeviceShaderAtomicFloat2FeaturesEXT& PhysicalDeviceShaderAtomicFloat2FeaturesEXT::operator=(
+    const PhysicalDeviceShaderAtomicFloat2FeaturesEXT& 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;
+}
+
+PhysicalDeviceShaderAtomicFloat2FeaturesEXT::~PhysicalDeviceShaderAtomicFloat2FeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderAtomicFloat2FeaturesEXT::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 PhysicalDeviceShaderAtomicFloat2FeaturesEXT::initialize(const PhysicalDeviceShaderAtomicFloat2FeaturesEXT* 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);
+}
+
+SurfacePresentModeEXT::SurfacePresentModeEXT(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);
+    }
+}
+
+SurfacePresentModeEXT::SurfacePresentModeEXT() : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT), pNext(nullptr), presentMode() {}
+
+SurfacePresentModeEXT::SurfacePresentModeEXT(const SurfacePresentModeEXT& copy_src) {
+    sType = copy_src.sType;
+    presentMode = copy_src.presentMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SurfacePresentModeEXT& SurfacePresentModeEXT::operator=(const SurfacePresentModeEXT& 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;
+}
+
+SurfacePresentModeEXT::~SurfacePresentModeEXT() { FreePnextChain(pNext); }
+
+void SurfacePresentModeEXT::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 SurfacePresentModeEXT::initialize(const SurfacePresentModeEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentMode = copy_src->presentMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SurfacePresentScalingCapabilitiesEXT::SurfacePresentScalingCapabilitiesEXT(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);
+    }
+}
+
+SurfacePresentScalingCapabilitiesEXT::SurfacePresentScalingCapabilitiesEXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT),
+      pNext(nullptr),
+      supportedPresentScaling(),
+      supportedPresentGravityX(),
+      supportedPresentGravityY(),
+      minScaledImageExtent(),
+      maxScaledImageExtent() {}
+
+SurfacePresentScalingCapabilitiesEXT::SurfacePresentScalingCapabilitiesEXT(const SurfacePresentScalingCapabilitiesEXT& 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);
+}
+
+SurfacePresentScalingCapabilitiesEXT& SurfacePresentScalingCapabilitiesEXT::operator=(
+    const SurfacePresentScalingCapabilitiesEXT& 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;
+}
+
+SurfacePresentScalingCapabilitiesEXT::~SurfacePresentScalingCapabilitiesEXT() { FreePnextChain(pNext); }
+
+void SurfacePresentScalingCapabilitiesEXT::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 SurfacePresentScalingCapabilitiesEXT::initialize(const SurfacePresentScalingCapabilitiesEXT* 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);
+}
+
+SurfacePresentModeCompatibilityEXT::SurfacePresentModeCompatibilityEXT(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);
+    }
+}
+
+SurfacePresentModeCompatibilityEXT::SurfacePresentModeCompatibilityEXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT), pNext(nullptr), presentModeCount(), pPresentModes(nullptr) {}
+
+SurfacePresentModeCompatibilityEXT::SurfacePresentModeCompatibilityEXT(const SurfacePresentModeCompatibilityEXT& 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);
+    }
+}
+
+SurfacePresentModeCompatibilityEXT& SurfacePresentModeCompatibilityEXT::operator=(
+    const SurfacePresentModeCompatibilityEXT& 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;
+}
+
+SurfacePresentModeCompatibilityEXT::~SurfacePresentModeCompatibilityEXT() {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+}
+
+void SurfacePresentModeCompatibilityEXT::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 SurfacePresentModeCompatibilityEXT::initialize(const SurfacePresentModeCompatibilityEXT* 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);
+    }
+}
+
+PhysicalDeviceSwapchainMaintenance1FeaturesEXT::PhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceSwapchainMaintenance1FeaturesEXT::PhysicalDeviceSwapchainMaintenance1FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT), pNext(nullptr), swapchainMaintenance1() {}
+
+PhysicalDeviceSwapchainMaintenance1FeaturesEXT::PhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    const PhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    swapchainMaintenance1 = copy_src.swapchainMaintenance1;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSwapchainMaintenance1FeaturesEXT& PhysicalDeviceSwapchainMaintenance1FeaturesEXT::operator=(
+    const PhysicalDeviceSwapchainMaintenance1FeaturesEXT& 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;
+}
+
+PhysicalDeviceSwapchainMaintenance1FeaturesEXT::~PhysicalDeviceSwapchainMaintenance1FeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSwapchainMaintenance1FeaturesEXT::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 PhysicalDeviceSwapchainMaintenance1FeaturesEXT::initialize(const PhysicalDeviceSwapchainMaintenance1FeaturesEXT* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchainMaintenance1 = copy_src->swapchainMaintenance1;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SwapchainPresentFenceInfoEXT::SwapchainPresentFenceInfoEXT(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];
+        }
+    }
+}
+
+SwapchainPresentFenceInfoEXT::SwapchainPresentFenceInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT), pNext(nullptr), swapchainCount(), pFences(nullptr) {}
+
+SwapchainPresentFenceInfoEXT::SwapchainPresentFenceInfoEXT(const SwapchainPresentFenceInfoEXT& 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];
+        }
+    }
+}
+
+SwapchainPresentFenceInfoEXT& SwapchainPresentFenceInfoEXT::operator=(const SwapchainPresentFenceInfoEXT& 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;
+}
+
+SwapchainPresentFenceInfoEXT::~SwapchainPresentFenceInfoEXT() {
+    if (pFences) delete[] pFences;
+    FreePnextChain(pNext);
+}
+
+void SwapchainPresentFenceInfoEXT::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 SwapchainPresentFenceInfoEXT::initialize(const SwapchainPresentFenceInfoEXT* 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];
+        }
+    }
+}
+
+SwapchainPresentModesCreateInfoEXT::SwapchainPresentModesCreateInfoEXT(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);
+    }
+}
+
+SwapchainPresentModesCreateInfoEXT::SwapchainPresentModesCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT),
+      pNext(nullptr),
+      presentModeCount(),
+      pPresentModes(nullptr) {}
+
+SwapchainPresentModesCreateInfoEXT::SwapchainPresentModesCreateInfoEXT(const SwapchainPresentModesCreateInfoEXT& 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);
+    }
+}
+
+SwapchainPresentModesCreateInfoEXT& SwapchainPresentModesCreateInfoEXT::operator=(
+    const SwapchainPresentModesCreateInfoEXT& 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;
+}
+
+SwapchainPresentModesCreateInfoEXT::~SwapchainPresentModesCreateInfoEXT() {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+}
+
+void SwapchainPresentModesCreateInfoEXT::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 SwapchainPresentModesCreateInfoEXT::initialize(const SwapchainPresentModesCreateInfoEXT* 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);
+    }
+}
+
+SwapchainPresentModeInfoEXT::SwapchainPresentModeInfoEXT(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);
+    }
+}
+
+SwapchainPresentModeInfoEXT::SwapchainPresentModeInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT), pNext(nullptr), swapchainCount(), pPresentModes(nullptr) {}
+
+SwapchainPresentModeInfoEXT::SwapchainPresentModeInfoEXT(const SwapchainPresentModeInfoEXT& 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);
+    }
+}
+
+SwapchainPresentModeInfoEXT& SwapchainPresentModeInfoEXT::operator=(const SwapchainPresentModeInfoEXT& 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;
+}
+
+SwapchainPresentModeInfoEXT::~SwapchainPresentModeInfoEXT() {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+}
+
+void SwapchainPresentModeInfoEXT::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 SwapchainPresentModeInfoEXT::initialize(const SwapchainPresentModeInfoEXT* 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);
+    }
+}
+
+SwapchainPresentScalingCreateInfoEXT::SwapchainPresentScalingCreateInfoEXT(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);
+    }
+}
+
+SwapchainPresentScalingCreateInfoEXT::SwapchainPresentScalingCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT),
+      pNext(nullptr),
+      scalingBehavior(),
+      presentGravityX(),
+      presentGravityY() {}
+
+SwapchainPresentScalingCreateInfoEXT::SwapchainPresentScalingCreateInfoEXT(const SwapchainPresentScalingCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    scalingBehavior = copy_src.scalingBehavior;
+    presentGravityX = copy_src.presentGravityX;
+    presentGravityY = copy_src.presentGravityY;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SwapchainPresentScalingCreateInfoEXT& SwapchainPresentScalingCreateInfoEXT::operator=(
+    const SwapchainPresentScalingCreateInfoEXT& 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;
+}
+
+SwapchainPresentScalingCreateInfoEXT::~SwapchainPresentScalingCreateInfoEXT() { FreePnextChain(pNext); }
+
+void SwapchainPresentScalingCreateInfoEXT::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 SwapchainPresentScalingCreateInfoEXT::initialize(const SwapchainPresentScalingCreateInfoEXT* 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);
+}
+
+ReleaseSwapchainImagesInfoEXT::ReleaseSwapchainImagesInfoEXT(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);
+    }
+}
+
+ReleaseSwapchainImagesInfoEXT::ReleaseSwapchainImagesInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT),
+      pNext(nullptr),
+      swapchain(),
+      imageIndexCount(),
+      pImageIndices(nullptr) {}
+
+ReleaseSwapchainImagesInfoEXT::ReleaseSwapchainImagesInfoEXT(const ReleaseSwapchainImagesInfoEXT& 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);
+    }
+}
+
+ReleaseSwapchainImagesInfoEXT& ReleaseSwapchainImagesInfoEXT::operator=(const ReleaseSwapchainImagesInfoEXT& 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;
+}
+
+ReleaseSwapchainImagesInfoEXT::~ReleaseSwapchainImagesInfoEXT() {
+    if (pImageIndices) delete[] pImageIndices;
+    FreePnextChain(pNext);
+}
+
+void ReleaseSwapchainImagesInfoEXT::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 ReleaseSwapchainImagesInfoEXT::initialize(const ReleaseSwapchainImagesInfoEXT* 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);
+    }
+}
+
+PhysicalDeviceTexelBufferAlignmentFeaturesEXT::PhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceTexelBufferAlignmentFeaturesEXT::PhysicalDeviceTexelBufferAlignmentFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT), pNext(nullptr), texelBufferAlignment() {}
+
+PhysicalDeviceTexelBufferAlignmentFeaturesEXT::PhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+    const PhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    texelBufferAlignment = copy_src.texelBufferAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceTexelBufferAlignmentFeaturesEXT& PhysicalDeviceTexelBufferAlignmentFeaturesEXT::operator=(
+    const PhysicalDeviceTexelBufferAlignmentFeaturesEXT& 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;
+}
+
+PhysicalDeviceTexelBufferAlignmentFeaturesEXT::~PhysicalDeviceTexelBufferAlignmentFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceTexelBufferAlignmentFeaturesEXT::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 PhysicalDeviceTexelBufferAlignmentFeaturesEXT::initialize(const PhysicalDeviceTexelBufferAlignmentFeaturesEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    texelBufferAlignment = copy_src->texelBufferAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDepthBiasControlFeaturesEXT::PhysicalDeviceDepthBiasControlFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceDepthBiasControlFeaturesEXT::PhysicalDeviceDepthBiasControlFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT),
+      pNext(nullptr),
+      depthBiasControl(),
+      leastRepresentableValueForceUnormRepresentation(),
+      floatRepresentation(),
+      depthBiasExact() {}
+
+PhysicalDeviceDepthBiasControlFeaturesEXT::PhysicalDeviceDepthBiasControlFeaturesEXT(
+    const PhysicalDeviceDepthBiasControlFeaturesEXT& 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);
+}
+
+PhysicalDeviceDepthBiasControlFeaturesEXT& PhysicalDeviceDepthBiasControlFeaturesEXT::operator=(
+    const PhysicalDeviceDepthBiasControlFeaturesEXT& 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;
+}
+
+PhysicalDeviceDepthBiasControlFeaturesEXT::~PhysicalDeviceDepthBiasControlFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDepthBiasControlFeaturesEXT::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 PhysicalDeviceDepthBiasControlFeaturesEXT::initialize(const PhysicalDeviceDepthBiasControlFeaturesEXT* 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);
+}
+
+DepthBiasInfoEXT::DepthBiasInfoEXT(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);
+    }
+}
+
+DepthBiasInfoEXT::DepthBiasInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT),
+      pNext(nullptr),
+      depthBiasConstantFactor(),
+      depthBiasClamp(),
+      depthBiasSlopeFactor() {}
+
+DepthBiasInfoEXT::DepthBiasInfoEXT(const DepthBiasInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    depthBiasConstantFactor = copy_src.depthBiasConstantFactor;
+    depthBiasClamp = copy_src.depthBiasClamp;
+    depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DepthBiasInfoEXT& DepthBiasInfoEXT::operator=(const DepthBiasInfoEXT& 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;
+}
+
+DepthBiasInfoEXT::~DepthBiasInfoEXT() { FreePnextChain(pNext); }
+
+void DepthBiasInfoEXT::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 DepthBiasInfoEXT::initialize(const DepthBiasInfoEXT* 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);
+}
+
+DepthBiasRepresentationInfoEXT::DepthBiasRepresentationInfoEXT(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);
+    }
+}
+
+DepthBiasRepresentationInfoEXT::DepthBiasRepresentationInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT), pNext(nullptr), depthBiasRepresentation(), depthBiasExact() {}
+
+DepthBiasRepresentationInfoEXT::DepthBiasRepresentationInfoEXT(const DepthBiasRepresentationInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    depthBiasRepresentation = copy_src.depthBiasRepresentation;
+    depthBiasExact = copy_src.depthBiasExact;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DepthBiasRepresentationInfoEXT& DepthBiasRepresentationInfoEXT::operator=(const DepthBiasRepresentationInfoEXT& 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;
+}
+
+DepthBiasRepresentationInfoEXT::~DepthBiasRepresentationInfoEXT() { FreePnextChain(pNext); }
+
+void DepthBiasRepresentationInfoEXT::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 DepthBiasRepresentationInfoEXT::initialize(const DepthBiasRepresentationInfoEXT* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthBiasRepresentation = copy_src->depthBiasRepresentation;
+    depthBiasExact = copy_src->depthBiasExact;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDeviceMemoryReportFeaturesEXT::PhysicalDeviceDeviceMemoryReportFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceDeviceMemoryReportFeaturesEXT::PhysicalDeviceDeviceMemoryReportFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT), pNext(nullptr), deviceMemoryReport() {}
+
+PhysicalDeviceDeviceMemoryReportFeaturesEXT::PhysicalDeviceDeviceMemoryReportFeaturesEXT(
+    const PhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    deviceMemoryReport = copy_src.deviceMemoryReport;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDeviceMemoryReportFeaturesEXT& PhysicalDeviceDeviceMemoryReportFeaturesEXT::operator=(
+    const PhysicalDeviceDeviceMemoryReportFeaturesEXT& 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;
+}
+
+PhysicalDeviceDeviceMemoryReportFeaturesEXT::~PhysicalDeviceDeviceMemoryReportFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDeviceMemoryReportFeaturesEXT::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 PhysicalDeviceDeviceMemoryReportFeaturesEXT::initialize(const PhysicalDeviceDeviceMemoryReportFeaturesEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceMemoryReport = copy_src->deviceMemoryReport;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DeviceMemoryReportCallbackDataEXT::DeviceMemoryReportCallbackDataEXT(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);
+    }
+}
+
+DeviceMemoryReportCallbackDataEXT::DeviceMemoryReportCallbackDataEXT()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT),
+      pNext(nullptr),
+      flags(),
+      type(),
+      memoryObjectId(),
+      size(),
+      objectType(),
+      objectHandle(),
+      heapIndex() {}
+
+DeviceMemoryReportCallbackDataEXT::DeviceMemoryReportCallbackDataEXT(const DeviceMemoryReportCallbackDataEXT& 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);
+}
+
+DeviceMemoryReportCallbackDataEXT& DeviceMemoryReportCallbackDataEXT::operator=(const DeviceMemoryReportCallbackDataEXT& 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;
+}
+
+DeviceMemoryReportCallbackDataEXT::~DeviceMemoryReportCallbackDataEXT() { FreePnextChain(pNext); }
+
+void DeviceMemoryReportCallbackDataEXT::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 DeviceMemoryReportCallbackDataEXT::initialize(const DeviceMemoryReportCallbackDataEXT* 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);
+}
+
+DeviceDeviceMemoryReportCreateInfoEXT::DeviceDeviceMemoryReportCreateInfoEXT(
+    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);
+    }
+}
+
+DeviceDeviceMemoryReportCreateInfoEXT::DeviceDeviceMemoryReportCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      pfnUserCallback(),
+      pUserData(nullptr) {}
+
+DeviceDeviceMemoryReportCreateInfoEXT::DeviceDeviceMemoryReportCreateInfoEXT(
+    const DeviceDeviceMemoryReportCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pfnUserCallback = copy_src.pfnUserCallback;
+    pUserData = copy_src.pUserData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceDeviceMemoryReportCreateInfoEXT& DeviceDeviceMemoryReportCreateInfoEXT::operator=(
+    const DeviceDeviceMemoryReportCreateInfoEXT& 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;
+}
+
+DeviceDeviceMemoryReportCreateInfoEXT::~DeviceDeviceMemoryReportCreateInfoEXT() { FreePnextChain(pNext); }
+
+void DeviceDeviceMemoryReportCreateInfoEXT::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 DeviceDeviceMemoryReportCreateInfoEXT::initialize(const DeviceDeviceMemoryReportCreateInfoEXT* 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);
+}
+
+PhysicalDeviceRobustness2FeaturesEXT::PhysicalDeviceRobustness2FeaturesEXT(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);
+    }
+}
+
+PhysicalDeviceRobustness2FeaturesEXT::PhysicalDeviceRobustness2FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT),
+      pNext(nullptr),
+      robustBufferAccess2(),
+      robustImageAccess2(),
+      nullDescriptor() {}
+
+PhysicalDeviceRobustness2FeaturesEXT::PhysicalDeviceRobustness2FeaturesEXT(const PhysicalDeviceRobustness2FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    robustBufferAccess2 = copy_src.robustBufferAccess2;
+    robustImageAccess2 = copy_src.robustImageAccess2;
+    nullDescriptor = copy_src.nullDescriptor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRobustness2FeaturesEXT& PhysicalDeviceRobustness2FeaturesEXT::operator=(
+    const PhysicalDeviceRobustness2FeaturesEXT& 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;
+}
+
+PhysicalDeviceRobustness2FeaturesEXT::~PhysicalDeviceRobustness2FeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRobustness2FeaturesEXT::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 PhysicalDeviceRobustness2FeaturesEXT::initialize(const PhysicalDeviceRobustness2FeaturesEXT* 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);
+}
+
+PhysicalDeviceRobustness2PropertiesEXT::PhysicalDeviceRobustness2PropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceRobustness2PropertiesEXT::PhysicalDeviceRobustness2PropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT),
+      pNext(nullptr),
+      robustStorageBufferAccessSizeAlignment(),
+      robustUniformBufferAccessSizeAlignment() {}
+
+PhysicalDeviceRobustness2PropertiesEXT::PhysicalDeviceRobustness2PropertiesEXT(
+    const PhysicalDeviceRobustness2PropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    robustStorageBufferAccessSizeAlignment = copy_src.robustStorageBufferAccessSizeAlignment;
+    robustUniformBufferAccessSizeAlignment = copy_src.robustUniformBufferAccessSizeAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRobustness2PropertiesEXT& PhysicalDeviceRobustness2PropertiesEXT::operator=(
+    const PhysicalDeviceRobustness2PropertiesEXT& 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;
+}
+
+PhysicalDeviceRobustness2PropertiesEXT::~PhysicalDeviceRobustness2PropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRobustness2PropertiesEXT::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 PhysicalDeviceRobustness2PropertiesEXT::initialize(const PhysicalDeviceRobustness2PropertiesEXT* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    robustStorageBufferAccessSizeAlignment = copy_src->robustStorageBufferAccessSizeAlignment;
+    robustUniformBufferAccessSizeAlignment = copy_src->robustUniformBufferAccessSizeAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SamplerCustomBorderColorCreateInfoEXT::SamplerCustomBorderColorCreateInfoEXT(
+    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);
+    }
+}
+
+SamplerCustomBorderColorCreateInfoEXT::SamplerCustomBorderColorCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT), pNext(nullptr), customBorderColor(), format() {}
+
+SamplerCustomBorderColorCreateInfoEXT::SamplerCustomBorderColorCreateInfoEXT(
+    const SamplerCustomBorderColorCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    customBorderColor = copy_src.customBorderColor;
+    format = copy_src.format;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SamplerCustomBorderColorCreateInfoEXT& SamplerCustomBorderColorCreateInfoEXT::operator=(
+    const SamplerCustomBorderColorCreateInfoEXT& 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;
+}
+
+SamplerCustomBorderColorCreateInfoEXT::~SamplerCustomBorderColorCreateInfoEXT() { FreePnextChain(pNext); }
+
+void SamplerCustomBorderColorCreateInfoEXT::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 SamplerCustomBorderColorCreateInfoEXT::initialize(const SamplerCustomBorderColorCreateInfoEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    customBorderColor = copy_src->customBorderColor;
+    format = copy_src->format;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceCustomBorderColorPropertiesEXT::PhysicalDeviceCustomBorderColorPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceCustomBorderColorPropertiesEXT::PhysicalDeviceCustomBorderColorPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT), pNext(nullptr), maxCustomBorderColorSamplers() {}
+
+PhysicalDeviceCustomBorderColorPropertiesEXT::PhysicalDeviceCustomBorderColorPropertiesEXT(
+    const PhysicalDeviceCustomBorderColorPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxCustomBorderColorSamplers = copy_src.maxCustomBorderColorSamplers;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCustomBorderColorPropertiesEXT& PhysicalDeviceCustomBorderColorPropertiesEXT::operator=(
+    const PhysicalDeviceCustomBorderColorPropertiesEXT& 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;
+}
+
+PhysicalDeviceCustomBorderColorPropertiesEXT::~PhysicalDeviceCustomBorderColorPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCustomBorderColorPropertiesEXT::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 PhysicalDeviceCustomBorderColorPropertiesEXT::initialize(const PhysicalDeviceCustomBorderColorPropertiesEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxCustomBorderColorSamplers = copy_src->maxCustomBorderColorSamplers;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceCustomBorderColorFeaturesEXT::PhysicalDeviceCustomBorderColorFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceCustomBorderColorFeaturesEXT::PhysicalDeviceCustomBorderColorFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT),
+      pNext(nullptr),
+      customBorderColors(),
+      customBorderColorWithoutFormat() {}
+
+PhysicalDeviceCustomBorderColorFeaturesEXT::PhysicalDeviceCustomBorderColorFeaturesEXT(
+    const PhysicalDeviceCustomBorderColorFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    customBorderColors = copy_src.customBorderColors;
+    customBorderColorWithoutFormat = copy_src.customBorderColorWithoutFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCustomBorderColorFeaturesEXT& PhysicalDeviceCustomBorderColorFeaturesEXT::operator=(
+    const PhysicalDeviceCustomBorderColorFeaturesEXT& 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;
+}
+
+PhysicalDeviceCustomBorderColorFeaturesEXT::~PhysicalDeviceCustomBorderColorFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCustomBorderColorFeaturesEXT::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 PhysicalDeviceCustomBorderColorFeaturesEXT::initialize(const PhysicalDeviceCustomBorderColorFeaturesEXT* 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
+
+ExportMetalObjectCreateInfoEXT::ExportMetalObjectCreateInfoEXT(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);
+    }
+}
+
+ExportMetalObjectCreateInfoEXT::ExportMetalObjectCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT), pNext(nullptr), exportObjectType() {}
+
+ExportMetalObjectCreateInfoEXT::ExportMetalObjectCreateInfoEXT(const ExportMetalObjectCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    exportObjectType = copy_src.exportObjectType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExportMetalObjectCreateInfoEXT& ExportMetalObjectCreateInfoEXT::operator=(const ExportMetalObjectCreateInfoEXT& 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;
+}
+
+ExportMetalObjectCreateInfoEXT::~ExportMetalObjectCreateInfoEXT() { FreePnextChain(pNext); }
+
+void ExportMetalObjectCreateInfoEXT::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 ExportMetalObjectCreateInfoEXT::initialize(const ExportMetalObjectCreateInfoEXT* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    exportObjectType = copy_src->exportObjectType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExportMetalObjectsInfoEXT::ExportMetalObjectsInfoEXT(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);
+    }
+}
+
+ExportMetalObjectsInfoEXT::ExportMetalObjectsInfoEXT() : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT), pNext(nullptr) {}
+
+ExportMetalObjectsInfoEXT::ExportMetalObjectsInfoEXT(const ExportMetalObjectsInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExportMetalObjectsInfoEXT& ExportMetalObjectsInfoEXT::operator=(const ExportMetalObjectsInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+ExportMetalObjectsInfoEXT::~ExportMetalObjectsInfoEXT() { FreePnextChain(pNext); }
+
+void ExportMetalObjectsInfoEXT::initialize(const VkExportMetalObjectsInfoEXT* in_struct,
+                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void ExportMetalObjectsInfoEXT::initialize(const ExportMetalObjectsInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExportMetalDeviceInfoEXT::ExportMetalDeviceInfoEXT(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);
+    }
+}
+
+ExportMetalDeviceInfoEXT::ExportMetalDeviceInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT), pNext(nullptr), mtlDevice() {}
+
+ExportMetalDeviceInfoEXT::ExportMetalDeviceInfoEXT(const ExportMetalDeviceInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    mtlDevice = copy_src.mtlDevice;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExportMetalDeviceInfoEXT& ExportMetalDeviceInfoEXT::operator=(const ExportMetalDeviceInfoEXT& 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;
+}
+
+ExportMetalDeviceInfoEXT::~ExportMetalDeviceInfoEXT() { FreePnextChain(pNext); }
+
+void ExportMetalDeviceInfoEXT::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 ExportMetalDeviceInfoEXT::initialize(const ExportMetalDeviceInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mtlDevice = copy_src->mtlDevice;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExportMetalCommandQueueInfoEXT::ExportMetalCommandQueueInfoEXT(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);
+    }
+}
+
+ExportMetalCommandQueueInfoEXT::ExportMetalCommandQueueInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT), pNext(nullptr), queue(), mtlCommandQueue() {}
+
+ExportMetalCommandQueueInfoEXT::ExportMetalCommandQueueInfoEXT(const ExportMetalCommandQueueInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    queue = copy_src.queue;
+    mtlCommandQueue = copy_src.mtlCommandQueue;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExportMetalCommandQueueInfoEXT& ExportMetalCommandQueueInfoEXT::operator=(const ExportMetalCommandQueueInfoEXT& 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;
+}
+
+ExportMetalCommandQueueInfoEXT::~ExportMetalCommandQueueInfoEXT() { FreePnextChain(pNext); }
+
+void ExportMetalCommandQueueInfoEXT::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 ExportMetalCommandQueueInfoEXT::initialize(const ExportMetalCommandQueueInfoEXT* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queue = copy_src->queue;
+    mtlCommandQueue = copy_src->mtlCommandQueue;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExportMetalBufferInfoEXT::ExportMetalBufferInfoEXT(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);
+    }
+}
+
+ExportMetalBufferInfoEXT::ExportMetalBufferInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT), pNext(nullptr), memory(), mtlBuffer() {}
+
+ExportMetalBufferInfoEXT::ExportMetalBufferInfoEXT(const ExportMetalBufferInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    mtlBuffer = copy_src.mtlBuffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExportMetalBufferInfoEXT& ExportMetalBufferInfoEXT::operator=(const ExportMetalBufferInfoEXT& 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;
+}
+
+ExportMetalBufferInfoEXT::~ExportMetalBufferInfoEXT() { FreePnextChain(pNext); }
+
+void ExportMetalBufferInfoEXT::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 ExportMetalBufferInfoEXT::initialize(const ExportMetalBufferInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    mtlBuffer = copy_src->mtlBuffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImportMetalBufferInfoEXT::ImportMetalBufferInfoEXT(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);
+    }
+}
+
+ImportMetalBufferInfoEXT::ImportMetalBufferInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT), pNext(nullptr), mtlBuffer() {}
+
+ImportMetalBufferInfoEXT::ImportMetalBufferInfoEXT(const ImportMetalBufferInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    mtlBuffer = copy_src.mtlBuffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImportMetalBufferInfoEXT& ImportMetalBufferInfoEXT::operator=(const ImportMetalBufferInfoEXT& 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;
+}
+
+ImportMetalBufferInfoEXT::~ImportMetalBufferInfoEXT() { FreePnextChain(pNext); }
+
+void ImportMetalBufferInfoEXT::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 ImportMetalBufferInfoEXT::initialize(const ImportMetalBufferInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mtlBuffer = copy_src->mtlBuffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExportMetalTextureInfoEXT::ExportMetalTextureInfoEXT(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);
+    }
+}
+
+ExportMetalTextureInfoEXT::ExportMetalTextureInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT),
+      pNext(nullptr),
+      image(),
+      imageView(),
+      bufferView(),
+      plane(),
+      mtlTexture() {}
+
+ExportMetalTextureInfoEXT::ExportMetalTextureInfoEXT(const ExportMetalTextureInfoEXT& 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);
+}
+
+ExportMetalTextureInfoEXT& ExportMetalTextureInfoEXT::operator=(const ExportMetalTextureInfoEXT& 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;
+}
+
+ExportMetalTextureInfoEXT::~ExportMetalTextureInfoEXT() { FreePnextChain(pNext); }
+
+void ExportMetalTextureInfoEXT::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 ExportMetalTextureInfoEXT::initialize(const ExportMetalTextureInfoEXT* 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);
+}
+
+ImportMetalTextureInfoEXT::ImportMetalTextureInfoEXT(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);
+    }
+}
+
+ImportMetalTextureInfoEXT::ImportMetalTextureInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT), pNext(nullptr), plane(), mtlTexture() {}
+
+ImportMetalTextureInfoEXT::ImportMetalTextureInfoEXT(const ImportMetalTextureInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    plane = copy_src.plane;
+    mtlTexture = copy_src.mtlTexture;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImportMetalTextureInfoEXT& ImportMetalTextureInfoEXT::operator=(const ImportMetalTextureInfoEXT& 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;
+}
+
+ImportMetalTextureInfoEXT::~ImportMetalTextureInfoEXT() { FreePnextChain(pNext); }
+
+void ImportMetalTextureInfoEXT::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 ImportMetalTextureInfoEXT::initialize(const ImportMetalTextureInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    plane = copy_src->plane;
+    mtlTexture = copy_src->mtlTexture;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExportMetalIOSurfaceInfoEXT::ExportMetalIOSurfaceInfoEXT(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);
+    }
+}
+
+ExportMetalIOSurfaceInfoEXT::ExportMetalIOSurfaceInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT), pNext(nullptr), image(), ioSurface() {}
+
+ExportMetalIOSurfaceInfoEXT::ExportMetalIOSurfaceInfoEXT(const ExportMetalIOSurfaceInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    ioSurface = copy_src.ioSurface;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExportMetalIOSurfaceInfoEXT& ExportMetalIOSurfaceInfoEXT::operator=(const ExportMetalIOSurfaceInfoEXT& 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;
+}
+
+ExportMetalIOSurfaceInfoEXT::~ExportMetalIOSurfaceInfoEXT() { FreePnextChain(pNext); }
+
+void ExportMetalIOSurfaceInfoEXT::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 ExportMetalIOSurfaceInfoEXT::initialize(const ExportMetalIOSurfaceInfoEXT* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    ioSurface = copy_src->ioSurface;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImportMetalIOSurfaceInfoEXT::ImportMetalIOSurfaceInfoEXT(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);
+    }
+}
+
+ImportMetalIOSurfaceInfoEXT::ImportMetalIOSurfaceInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT), pNext(nullptr), ioSurface() {}
+
+ImportMetalIOSurfaceInfoEXT::ImportMetalIOSurfaceInfoEXT(const ImportMetalIOSurfaceInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    ioSurface = copy_src.ioSurface;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImportMetalIOSurfaceInfoEXT& ImportMetalIOSurfaceInfoEXT::operator=(const ImportMetalIOSurfaceInfoEXT& 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;
+}
+
+ImportMetalIOSurfaceInfoEXT::~ImportMetalIOSurfaceInfoEXT() { FreePnextChain(pNext); }
+
+void ImportMetalIOSurfaceInfoEXT::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 ImportMetalIOSurfaceInfoEXT::initialize(const ImportMetalIOSurfaceInfoEXT* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    ioSurface = copy_src->ioSurface;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExportMetalSharedEventInfoEXT::ExportMetalSharedEventInfoEXT(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);
+    }
+}
+
+ExportMetalSharedEventInfoEXT::ExportMetalSharedEventInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT), pNext(nullptr), semaphore(), event(), mtlSharedEvent() {}
+
+ExportMetalSharedEventInfoEXT::ExportMetalSharedEventInfoEXT(const ExportMetalSharedEventInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    event = copy_src.event;
+    mtlSharedEvent = copy_src.mtlSharedEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExportMetalSharedEventInfoEXT& ExportMetalSharedEventInfoEXT::operator=(const ExportMetalSharedEventInfoEXT& 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;
+}
+
+ExportMetalSharedEventInfoEXT::~ExportMetalSharedEventInfoEXT() { FreePnextChain(pNext); }
+
+void ExportMetalSharedEventInfoEXT::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 ExportMetalSharedEventInfoEXT::initialize(const ExportMetalSharedEventInfoEXT* 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);
+}
+
+ImportMetalSharedEventInfoEXT::ImportMetalSharedEventInfoEXT(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);
+    }
+}
+
+ImportMetalSharedEventInfoEXT::ImportMetalSharedEventInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT), pNext(nullptr), mtlSharedEvent() {}
+
+ImportMetalSharedEventInfoEXT::ImportMetalSharedEventInfoEXT(const ImportMetalSharedEventInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    mtlSharedEvent = copy_src.mtlSharedEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImportMetalSharedEventInfoEXT& ImportMetalSharedEventInfoEXT::operator=(const ImportMetalSharedEventInfoEXT& 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;
+}
+
+ImportMetalSharedEventInfoEXT::~ImportMetalSharedEventInfoEXT() { FreePnextChain(pNext); }
+
+void ImportMetalSharedEventInfoEXT::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 ImportMetalSharedEventInfoEXT::initialize(const ImportMetalSharedEventInfoEXT* 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
+
+PhysicalDeviceDescriptorBufferPropertiesEXT::PhysicalDeviceDescriptorBufferPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceDescriptorBufferPropertiesEXT::PhysicalDeviceDescriptorBufferPropertiesEXT()
+    : 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() {}
+
+PhysicalDeviceDescriptorBufferPropertiesEXT::PhysicalDeviceDescriptorBufferPropertiesEXT(
+    const PhysicalDeviceDescriptorBufferPropertiesEXT& 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);
+}
+
+PhysicalDeviceDescriptorBufferPropertiesEXT& PhysicalDeviceDescriptorBufferPropertiesEXT::operator=(
+    const PhysicalDeviceDescriptorBufferPropertiesEXT& 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;
+}
+
+PhysicalDeviceDescriptorBufferPropertiesEXT::~PhysicalDeviceDescriptorBufferPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDescriptorBufferPropertiesEXT::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 PhysicalDeviceDescriptorBufferPropertiesEXT::initialize(const PhysicalDeviceDescriptorBufferPropertiesEXT* 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);
+}
+
+PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT),
+      pNext(nullptr),
+      combinedImageSamplerDensityMapDescriptorSize() {}
+
+PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    const PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    combinedImageSamplerDensityMapDescriptorSize = copy_src.combinedImageSamplerDensityMapDescriptorSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::operator=(
+    const PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& 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;
+}
+
+PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::~PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::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 PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::initialize(
+    const PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    combinedImageSamplerDensityMapDescriptorSize = copy_src->combinedImageSamplerDensityMapDescriptorSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDescriptorBufferFeaturesEXT::PhysicalDeviceDescriptorBufferFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceDescriptorBufferFeaturesEXT::PhysicalDeviceDescriptorBufferFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT),
+      pNext(nullptr),
+      descriptorBuffer(),
+      descriptorBufferCaptureReplay(),
+      descriptorBufferImageLayoutIgnored(),
+      descriptorBufferPushDescriptors() {}
+
+PhysicalDeviceDescriptorBufferFeaturesEXT::PhysicalDeviceDescriptorBufferFeaturesEXT(
+    const PhysicalDeviceDescriptorBufferFeaturesEXT& 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);
+}
+
+PhysicalDeviceDescriptorBufferFeaturesEXT& PhysicalDeviceDescriptorBufferFeaturesEXT::operator=(
+    const PhysicalDeviceDescriptorBufferFeaturesEXT& 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;
+}
+
+PhysicalDeviceDescriptorBufferFeaturesEXT::~PhysicalDeviceDescriptorBufferFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDescriptorBufferFeaturesEXT::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 PhysicalDeviceDescriptorBufferFeaturesEXT::initialize(const PhysicalDeviceDescriptorBufferFeaturesEXT* 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);
+}
+
+DescriptorAddressInfoEXT::DescriptorAddressInfoEXT(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);
+    }
+}
+
+DescriptorAddressInfoEXT::DescriptorAddressInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT), pNext(nullptr), address(), range(), format() {}
+
+DescriptorAddressInfoEXT::DescriptorAddressInfoEXT(const DescriptorAddressInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    address = copy_src.address;
+    range = copy_src.range;
+    format = copy_src.format;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DescriptorAddressInfoEXT& DescriptorAddressInfoEXT::operator=(const DescriptorAddressInfoEXT& 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;
+}
+
+DescriptorAddressInfoEXT::~DescriptorAddressInfoEXT() { FreePnextChain(pNext); }
+
+void DescriptorAddressInfoEXT::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 DescriptorAddressInfoEXT::initialize(const DescriptorAddressInfoEXT* 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);
+}
+
+DescriptorBufferBindingInfoEXT::DescriptorBufferBindingInfoEXT(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);
+    }
+}
+
+DescriptorBufferBindingInfoEXT::DescriptorBufferBindingInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT), pNext(nullptr), address(), usage() {}
+
+DescriptorBufferBindingInfoEXT::DescriptorBufferBindingInfoEXT(const DescriptorBufferBindingInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    address = copy_src.address;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DescriptorBufferBindingInfoEXT& DescriptorBufferBindingInfoEXT::operator=(const DescriptorBufferBindingInfoEXT& 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;
+}
+
+DescriptorBufferBindingInfoEXT::~DescriptorBufferBindingInfoEXT() { FreePnextChain(pNext); }
+
+void DescriptorBufferBindingInfoEXT::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 DescriptorBufferBindingInfoEXT::initialize(const DescriptorBufferBindingInfoEXT* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    address = copy_src->address;
+    usage = copy_src->usage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DescriptorBufferBindingPushDescriptorBufferHandleEXT::DescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    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);
+    }
+}
+
+DescriptorBufferBindingPushDescriptorBufferHandleEXT::DescriptorBufferBindingPushDescriptorBufferHandleEXT()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT), pNext(nullptr), buffer() {}
+
+DescriptorBufferBindingPushDescriptorBufferHandleEXT::DescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    const DescriptorBufferBindingPushDescriptorBufferHandleEXT& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DescriptorBufferBindingPushDescriptorBufferHandleEXT& DescriptorBufferBindingPushDescriptorBufferHandleEXT::operator=(
+    const DescriptorBufferBindingPushDescriptorBufferHandleEXT& 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;
+}
+
+DescriptorBufferBindingPushDescriptorBufferHandleEXT::~DescriptorBufferBindingPushDescriptorBufferHandleEXT() {
+    FreePnextChain(pNext);
+}
+
+void DescriptorBufferBindingPushDescriptorBufferHandleEXT::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 DescriptorBufferBindingPushDescriptorBufferHandleEXT::initialize(
+    const DescriptorBufferBindingPushDescriptorBufferHandleEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DescriptorGetInfoEXT::DescriptorGetInfoEXT(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);
+    }
+}
+
+DescriptorGetInfoEXT::DescriptorGetInfoEXT() : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT), pNext(nullptr), type() {}
+
+DescriptorGetInfoEXT::DescriptorGetInfoEXT(const DescriptorGetInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    data.initialize(&copy_src.data);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DescriptorGetInfoEXT& DescriptorGetInfoEXT::operator=(const DescriptorGetInfoEXT& 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;
+}
+
+DescriptorGetInfoEXT::~DescriptorGetInfoEXT() { FreePnextChain(pNext); }
+
+void DescriptorGetInfoEXT::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 DescriptorGetInfoEXT::initialize(const DescriptorGetInfoEXT* 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);
+}
+
+BufferCaptureDescriptorDataInfoEXT::BufferCaptureDescriptorDataInfoEXT(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);
+    }
+}
+
+BufferCaptureDescriptorDataInfoEXT::BufferCaptureDescriptorDataInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), buffer() {}
+
+BufferCaptureDescriptorDataInfoEXT::BufferCaptureDescriptorDataInfoEXT(const BufferCaptureDescriptorDataInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BufferCaptureDescriptorDataInfoEXT& BufferCaptureDescriptorDataInfoEXT::operator=(
+    const BufferCaptureDescriptorDataInfoEXT& 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;
+}
+
+BufferCaptureDescriptorDataInfoEXT::~BufferCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); }
+
+void BufferCaptureDescriptorDataInfoEXT::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 BufferCaptureDescriptorDataInfoEXT::initialize(const BufferCaptureDescriptorDataInfoEXT* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImageCaptureDescriptorDataInfoEXT::ImageCaptureDescriptorDataInfoEXT(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);
+    }
+}
+
+ImageCaptureDescriptorDataInfoEXT::ImageCaptureDescriptorDataInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), image() {}
+
+ImageCaptureDescriptorDataInfoEXT::ImageCaptureDescriptorDataInfoEXT(const ImageCaptureDescriptorDataInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageCaptureDescriptorDataInfoEXT& ImageCaptureDescriptorDataInfoEXT::operator=(const ImageCaptureDescriptorDataInfoEXT& 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;
+}
+
+ImageCaptureDescriptorDataInfoEXT::~ImageCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); }
+
+void ImageCaptureDescriptorDataInfoEXT::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 ImageCaptureDescriptorDataInfoEXT::initialize(const ImageCaptureDescriptorDataInfoEXT* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImageViewCaptureDescriptorDataInfoEXT::ImageViewCaptureDescriptorDataInfoEXT(
+    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);
+    }
+}
+
+ImageViewCaptureDescriptorDataInfoEXT::ImageViewCaptureDescriptorDataInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), imageView() {}
+
+ImageViewCaptureDescriptorDataInfoEXT::ImageViewCaptureDescriptorDataInfoEXT(
+    const ImageViewCaptureDescriptorDataInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageViewCaptureDescriptorDataInfoEXT& ImageViewCaptureDescriptorDataInfoEXT::operator=(
+    const ImageViewCaptureDescriptorDataInfoEXT& 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;
+}
+
+ImageViewCaptureDescriptorDataInfoEXT::~ImageViewCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); }
+
+void ImageViewCaptureDescriptorDataInfoEXT::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 ImageViewCaptureDescriptorDataInfoEXT::initialize(const ImageViewCaptureDescriptorDataInfoEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageView = copy_src->imageView;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SamplerCaptureDescriptorDataInfoEXT::SamplerCaptureDescriptorDataInfoEXT(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);
+    }
+}
+
+SamplerCaptureDescriptorDataInfoEXT::SamplerCaptureDescriptorDataInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), sampler() {}
+
+SamplerCaptureDescriptorDataInfoEXT::SamplerCaptureDescriptorDataInfoEXT(const SamplerCaptureDescriptorDataInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    sampler = copy_src.sampler;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SamplerCaptureDescriptorDataInfoEXT& SamplerCaptureDescriptorDataInfoEXT::operator=(
+    const SamplerCaptureDescriptorDataInfoEXT& 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;
+}
+
+SamplerCaptureDescriptorDataInfoEXT::~SamplerCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); }
+
+void SamplerCaptureDescriptorDataInfoEXT::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 SamplerCaptureDescriptorDataInfoEXT::initialize(const SamplerCaptureDescriptorDataInfoEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    sampler = copy_src->sampler;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+OpaqueCaptureDescriptorDataCreateInfoEXT::OpaqueCaptureDescriptorDataCreateInfoEXT(
+    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);
+    }
+}
+
+OpaqueCaptureDescriptorDataCreateInfoEXT::OpaqueCaptureDescriptorDataCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT),
+      pNext(nullptr),
+      opaqueCaptureDescriptorData(nullptr) {}
+
+OpaqueCaptureDescriptorDataCreateInfoEXT::OpaqueCaptureDescriptorDataCreateInfoEXT(
+    const OpaqueCaptureDescriptorDataCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    opaqueCaptureDescriptorData = copy_src.opaqueCaptureDescriptorData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+OpaqueCaptureDescriptorDataCreateInfoEXT& OpaqueCaptureDescriptorDataCreateInfoEXT::operator=(
+    const OpaqueCaptureDescriptorDataCreateInfoEXT& 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;
+}
+
+OpaqueCaptureDescriptorDataCreateInfoEXT::~OpaqueCaptureDescriptorDataCreateInfoEXT() { FreePnextChain(pNext); }
+
+void OpaqueCaptureDescriptorDataCreateInfoEXT::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 OpaqueCaptureDescriptorDataCreateInfoEXT::initialize(const OpaqueCaptureDescriptorDataCreateInfoEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    opaqueCaptureDescriptorData = copy_src->opaqueCaptureDescriptorData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+AccelerationStructureCaptureDescriptorDataInfoEXT::AccelerationStructureCaptureDescriptorDataInfoEXT(
+    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);
+    }
+}
+
+AccelerationStructureCaptureDescriptorDataInfoEXT::AccelerationStructureCaptureDescriptorDataInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT),
+      pNext(nullptr),
+      accelerationStructure(),
+      accelerationStructureNV() {}
+
+AccelerationStructureCaptureDescriptorDataInfoEXT::AccelerationStructureCaptureDescriptorDataInfoEXT(
+    const AccelerationStructureCaptureDescriptorDataInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructure = copy_src.accelerationStructure;
+    accelerationStructureNV = copy_src.accelerationStructureNV;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AccelerationStructureCaptureDescriptorDataInfoEXT& AccelerationStructureCaptureDescriptorDataInfoEXT::operator=(
+    const AccelerationStructureCaptureDescriptorDataInfoEXT& 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;
+}
+
+AccelerationStructureCaptureDescriptorDataInfoEXT::~AccelerationStructureCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); }
+
+void AccelerationStructureCaptureDescriptorDataInfoEXT::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 AccelerationStructureCaptureDescriptorDataInfoEXT::initialize(
+    const AccelerationStructureCaptureDescriptorDataInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    accelerationStructure = copy_src->accelerationStructure;
+    accelerationStructureNV = copy_src->accelerationStructureNV;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT), pNext(nullptr), graphicsPipelineLibrary() {}
+
+PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    const PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    graphicsPipelineLibrary = copy_src.graphicsPipelineLibrary;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::operator=(
+    const PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& 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;
+}
+
+PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::~PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::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 PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::initialize(const PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    graphicsPipelineLibrary = copy_src->graphicsPipelineLibrary;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT),
+      pNext(nullptr),
+      graphicsPipelineLibraryFastLinking(),
+      graphicsPipelineLibraryIndependentInterpolationDecoration() {}
+
+PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    const PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    graphicsPipelineLibraryFastLinking = copy_src.graphicsPipelineLibraryFastLinking;
+    graphicsPipelineLibraryIndependentInterpolationDecoration = copy_src.graphicsPipelineLibraryIndependentInterpolationDecoration;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::operator=(
+    const PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& 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;
+}
+
+PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::~PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::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 PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::initialize(
+    const PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    graphicsPipelineLibraryFastLinking = copy_src->graphicsPipelineLibraryFastLinking;
+    graphicsPipelineLibraryIndependentInterpolationDecoration = copy_src->graphicsPipelineLibraryIndependentInterpolationDecoration;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+GraphicsPipelineLibraryCreateInfoEXT::GraphicsPipelineLibraryCreateInfoEXT(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);
+    }
+}
+
+GraphicsPipelineLibraryCreateInfoEXT::GraphicsPipelineLibraryCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT), pNext(nullptr), flags() {}
+
+GraphicsPipelineLibraryCreateInfoEXT::GraphicsPipelineLibraryCreateInfoEXT(const GraphicsPipelineLibraryCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+GraphicsPipelineLibraryCreateInfoEXT& GraphicsPipelineLibraryCreateInfoEXT::operator=(
+    const GraphicsPipelineLibraryCreateInfoEXT& 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;
+}
+
+GraphicsPipelineLibraryCreateInfoEXT::~GraphicsPipelineLibraryCreateInfoEXT() { FreePnextChain(pNext); }
+
+void GraphicsPipelineLibraryCreateInfoEXT::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 GraphicsPipelineLibraryCreateInfoEXT::initialize(const GraphicsPipelineLibraryCreateInfoEXT* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT), pNext(nullptr), ycbcr2plane444Formats() {}
+
+PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+    const PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    ycbcr2plane444Formats = copy_src.ycbcr2plane444Formats;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::operator=(
+    const PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& 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;
+}
+
+PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::~PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::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 PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::initialize(const PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    ycbcr2plane444Formats = copy_src->ycbcr2plane444Formats;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceFragmentDensityMap2FeaturesEXT::PhysicalDeviceFragmentDensityMap2FeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentDensityMap2FeaturesEXT::PhysicalDeviceFragmentDensityMap2FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT), pNext(nullptr), fragmentDensityMapDeferred() {}
+
+PhysicalDeviceFragmentDensityMap2FeaturesEXT::PhysicalDeviceFragmentDensityMap2FeaturesEXT(
+    const PhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityMapDeferred = copy_src.fragmentDensityMapDeferred;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentDensityMap2FeaturesEXT& PhysicalDeviceFragmentDensityMap2FeaturesEXT::operator=(
+    const PhysicalDeviceFragmentDensityMap2FeaturesEXT& 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;
+}
+
+PhysicalDeviceFragmentDensityMap2FeaturesEXT::~PhysicalDeviceFragmentDensityMap2FeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentDensityMap2FeaturesEXT::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 PhysicalDeviceFragmentDensityMap2FeaturesEXT::initialize(const PhysicalDeviceFragmentDensityMap2FeaturesEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityMapDeferred = copy_src->fragmentDensityMapDeferred;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceFragmentDensityMap2PropertiesEXT::PhysicalDeviceFragmentDensityMap2PropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentDensityMap2PropertiesEXT::PhysicalDeviceFragmentDensityMap2PropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT),
+      pNext(nullptr),
+      subsampledLoads(),
+      subsampledCoarseReconstructionEarlyAccess(),
+      maxSubsampledArrayLayers(),
+      maxDescriptorSetSubsampledSamplers() {}
+
+PhysicalDeviceFragmentDensityMap2PropertiesEXT::PhysicalDeviceFragmentDensityMap2PropertiesEXT(
+    const PhysicalDeviceFragmentDensityMap2PropertiesEXT& 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);
+}
+
+PhysicalDeviceFragmentDensityMap2PropertiesEXT& PhysicalDeviceFragmentDensityMap2PropertiesEXT::operator=(
+    const PhysicalDeviceFragmentDensityMap2PropertiesEXT& 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;
+}
+
+PhysicalDeviceFragmentDensityMap2PropertiesEXT::~PhysicalDeviceFragmentDensityMap2PropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentDensityMap2PropertiesEXT::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 PhysicalDeviceFragmentDensityMap2PropertiesEXT::initialize(const PhysicalDeviceFragmentDensityMap2PropertiesEXT* 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);
+}
+
+PhysicalDeviceImageCompressionControlFeaturesEXT::PhysicalDeviceImageCompressionControlFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceImageCompressionControlFeaturesEXT::PhysicalDeviceImageCompressionControlFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT), pNext(nullptr), imageCompressionControl() {}
+
+PhysicalDeviceImageCompressionControlFeaturesEXT::PhysicalDeviceImageCompressionControlFeaturesEXT(
+    const PhysicalDeviceImageCompressionControlFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    imageCompressionControl = copy_src.imageCompressionControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceImageCompressionControlFeaturesEXT& PhysicalDeviceImageCompressionControlFeaturesEXT::operator=(
+    const PhysicalDeviceImageCompressionControlFeaturesEXT& 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;
+}
+
+PhysicalDeviceImageCompressionControlFeaturesEXT::~PhysicalDeviceImageCompressionControlFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImageCompressionControlFeaturesEXT::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 PhysicalDeviceImageCompressionControlFeaturesEXT::initialize(const PhysicalDeviceImageCompressionControlFeaturesEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageCompressionControl = copy_src->imageCompressionControl;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImageCompressionControlEXT::ImageCompressionControlEXT(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);
+    }
+}
+
+ImageCompressionControlEXT::ImageCompressionControlEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT),
+      pNext(nullptr),
+      flags(),
+      compressionControlPlaneCount(),
+      pFixedRateFlags(nullptr) {}
+
+ImageCompressionControlEXT::ImageCompressionControlEXT(const ImageCompressionControlEXT& 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);
+    }
+}
+
+ImageCompressionControlEXT& ImageCompressionControlEXT::operator=(const ImageCompressionControlEXT& 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;
+}
+
+ImageCompressionControlEXT::~ImageCompressionControlEXT() {
+    if (pFixedRateFlags) delete[] pFixedRateFlags;
+    FreePnextChain(pNext);
+}
+
+void ImageCompressionControlEXT::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 ImageCompressionControlEXT::initialize(const ImageCompressionControlEXT* 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);
+    }
+}
+
+ImageCompressionPropertiesEXT::ImageCompressionPropertiesEXT(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);
+    }
+}
+
+ImageCompressionPropertiesEXT::ImageCompressionPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT),
+      pNext(nullptr),
+      imageCompressionFlags(),
+      imageCompressionFixedRateFlags() {}
+
+ImageCompressionPropertiesEXT::ImageCompressionPropertiesEXT(const ImageCompressionPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    imageCompressionFlags = copy_src.imageCompressionFlags;
+    imageCompressionFixedRateFlags = copy_src.imageCompressionFixedRateFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageCompressionPropertiesEXT& ImageCompressionPropertiesEXT::operator=(const ImageCompressionPropertiesEXT& 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;
+}
+
+ImageCompressionPropertiesEXT::~ImageCompressionPropertiesEXT() { FreePnextChain(pNext); }
+
+void ImageCompressionPropertiesEXT::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 ImageCompressionPropertiesEXT::initialize(const ImageCompressionPropertiesEXT* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageCompressionFlags = copy_src->imageCompressionFlags;
+    imageCompressionFixedRateFlags = copy_src->imageCompressionFixedRateFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT),
+      pNext(nullptr),
+      attachmentFeedbackLoopLayout() {}
+
+PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    const PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    attachmentFeedbackLoopLayout = copy_src.attachmentFeedbackLoopLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::operator=(
+    const PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& 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;
+}
+
+PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::~PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::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 PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::initialize(
+    const PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    attachmentFeedbackLoopLayout = copy_src->attachmentFeedbackLoopLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevice4444FormatsFeaturesEXT::PhysicalDevice4444FormatsFeaturesEXT(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);
+    }
+}
+
+PhysicalDevice4444FormatsFeaturesEXT::PhysicalDevice4444FormatsFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT), pNext(nullptr), formatA4R4G4B4(), formatA4B4G4R4() {}
+
+PhysicalDevice4444FormatsFeaturesEXT::PhysicalDevice4444FormatsFeaturesEXT(const PhysicalDevice4444FormatsFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    formatA4R4G4B4 = copy_src.formatA4R4G4B4;
+    formatA4B4G4R4 = copy_src.formatA4B4G4R4;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevice4444FormatsFeaturesEXT& PhysicalDevice4444FormatsFeaturesEXT::operator=(
+    const PhysicalDevice4444FormatsFeaturesEXT& 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;
+}
+
+PhysicalDevice4444FormatsFeaturesEXT::~PhysicalDevice4444FormatsFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDevice4444FormatsFeaturesEXT::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 PhysicalDevice4444FormatsFeaturesEXT::initialize(const PhysicalDevice4444FormatsFeaturesEXT* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    formatA4R4G4B4 = copy_src->formatA4R4G4B4;
+    formatA4B4G4R4 = copy_src->formatA4B4G4R4;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceFaultFeaturesEXT::PhysicalDeviceFaultFeaturesEXT(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);
+    }
+}
+
+PhysicalDeviceFaultFeaturesEXT::PhysicalDeviceFaultFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT), pNext(nullptr), deviceFault(), deviceFaultVendorBinary() {}
+
+PhysicalDeviceFaultFeaturesEXT::PhysicalDeviceFaultFeaturesEXT(const PhysicalDeviceFaultFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    deviceFault = copy_src.deviceFault;
+    deviceFaultVendorBinary = copy_src.deviceFaultVendorBinary;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFaultFeaturesEXT& PhysicalDeviceFaultFeaturesEXT::operator=(const PhysicalDeviceFaultFeaturesEXT& 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;
+}
+
+PhysicalDeviceFaultFeaturesEXT::~PhysicalDeviceFaultFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFaultFeaturesEXT::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 PhysicalDeviceFaultFeaturesEXT::initialize(const PhysicalDeviceFaultFeaturesEXT* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceFault = copy_src->deviceFault;
+    deviceFaultVendorBinary = copy_src->deviceFaultVendorBinary;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DeviceFaultCountsEXT::DeviceFaultCountsEXT(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);
+    }
+}
+
+DeviceFaultCountsEXT::DeviceFaultCountsEXT()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT), pNext(nullptr), addressInfoCount(), vendorInfoCount(), vendorBinarySize() {}
+
+DeviceFaultCountsEXT::DeviceFaultCountsEXT(const DeviceFaultCountsEXT& copy_src) {
+    sType = copy_src.sType;
+    addressInfoCount = copy_src.addressInfoCount;
+    vendorInfoCount = copy_src.vendorInfoCount;
+    vendorBinarySize = copy_src.vendorBinarySize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceFaultCountsEXT& DeviceFaultCountsEXT::operator=(const DeviceFaultCountsEXT& 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;
+}
+
+DeviceFaultCountsEXT::~DeviceFaultCountsEXT() { FreePnextChain(pNext); }
+
+void DeviceFaultCountsEXT::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 DeviceFaultCountsEXT::initialize(const DeviceFaultCountsEXT* 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);
+}
+
+DeviceFaultInfoEXT::DeviceFaultInfoEXT(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);
+    }
+}
+
+DeviceFaultInfoEXT::DeviceFaultInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT),
+      pNext(nullptr),
+      pAddressInfos(nullptr),
+      pVendorInfos(nullptr),
+      pVendorBinaryData(nullptr) {}
+
+DeviceFaultInfoEXT::DeviceFaultInfoEXT(const DeviceFaultInfoEXT& 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);
+    }
+}
+
+DeviceFaultInfoEXT& DeviceFaultInfoEXT::operator=(const DeviceFaultInfoEXT& 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;
+}
+
+DeviceFaultInfoEXT::~DeviceFaultInfoEXT() {
+    if (pAddressInfos) delete pAddressInfos;
+    if (pVendorInfos) delete pVendorInfos;
+    FreePnextChain(pNext);
+}
+
+void DeviceFaultInfoEXT::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 DeviceFaultInfoEXT::initialize(const DeviceFaultInfoEXT* 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);
+    }
+}
+
+PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT),
+      pNext(nullptr),
+      rasterizationOrderColorAttachmentAccess(),
+      rasterizationOrderDepthAttachmentAccess(),
+      rasterizationOrderStencilAttachmentAccess() {}
+
+PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    const PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    rasterizationOrderColorAttachmentAccess = copy_src.rasterizationOrderColorAttachmentAccess;
+    rasterizationOrderDepthAttachmentAccess = copy_src.rasterizationOrderDepthAttachmentAccess;
+    rasterizationOrderStencilAttachmentAccess = copy_src.rasterizationOrderStencilAttachmentAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::operator=(
+    const PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& 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;
+}
+
+PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::~PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::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 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::initialize(
+    const PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* 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);
+}
+
+PhysicalDeviceRGBA10X6FormatsFeaturesEXT::PhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceRGBA10X6FormatsFeaturesEXT::PhysicalDeviceRGBA10X6FormatsFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT), pNext(nullptr), formatRgba10x6WithoutYCbCrSampler() {}
+
+PhysicalDeviceRGBA10X6FormatsFeaturesEXT::PhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+    const PhysicalDeviceRGBA10X6FormatsFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    formatRgba10x6WithoutYCbCrSampler = copy_src.formatRgba10x6WithoutYCbCrSampler;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRGBA10X6FormatsFeaturesEXT& PhysicalDeviceRGBA10X6FormatsFeaturesEXT::operator=(
+    const PhysicalDeviceRGBA10X6FormatsFeaturesEXT& 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;
+}
+
+PhysicalDeviceRGBA10X6FormatsFeaturesEXT::~PhysicalDeviceRGBA10X6FormatsFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRGBA10X6FormatsFeaturesEXT::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 PhysicalDeviceRGBA10X6FormatsFeaturesEXT::initialize(const PhysicalDeviceRGBA10X6FormatsFeaturesEXT* 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
+
+DirectFBSurfaceCreateInfoEXT::DirectFBSurfaceCreateInfoEXT(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);
+    }
+}
+
+DirectFBSurfaceCreateInfoEXT::DirectFBSurfaceCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT), pNext(nullptr), flags(), dfb(nullptr), surface(nullptr) {}
+
+DirectFBSurfaceCreateInfoEXT::DirectFBSurfaceCreateInfoEXT(const DirectFBSurfaceCreateInfoEXT& 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);
+    }
+}
+
+DirectFBSurfaceCreateInfoEXT& DirectFBSurfaceCreateInfoEXT::operator=(const DirectFBSurfaceCreateInfoEXT& 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;
+}
+
+DirectFBSurfaceCreateInfoEXT::~DirectFBSurfaceCreateInfoEXT() {
+    if (dfb) delete dfb;
+    if (surface) delete surface;
+    FreePnextChain(pNext);
+}
+
+void DirectFBSurfaceCreateInfoEXT::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 DirectFBSurfaceCreateInfoEXT::initialize(const DirectFBSurfaceCreateInfoEXT* 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
+
+PhysicalDeviceMutableDescriptorTypeFeaturesEXT::PhysicalDeviceMutableDescriptorTypeFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceMutableDescriptorTypeFeaturesEXT::PhysicalDeviceMutableDescriptorTypeFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT), pNext(nullptr), mutableDescriptorType() {}
+
+PhysicalDeviceMutableDescriptorTypeFeaturesEXT::PhysicalDeviceMutableDescriptorTypeFeaturesEXT(
+    const PhysicalDeviceMutableDescriptorTypeFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    mutableDescriptorType = copy_src.mutableDescriptorType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMutableDescriptorTypeFeaturesEXT& PhysicalDeviceMutableDescriptorTypeFeaturesEXT::operator=(
+    const PhysicalDeviceMutableDescriptorTypeFeaturesEXT& 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;
+}
+
+PhysicalDeviceMutableDescriptorTypeFeaturesEXT::~PhysicalDeviceMutableDescriptorTypeFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMutableDescriptorTypeFeaturesEXT::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 PhysicalDeviceMutableDescriptorTypeFeaturesEXT::initialize(const PhysicalDeviceMutableDescriptorTypeFeaturesEXT* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mutableDescriptorType = copy_src->mutableDescriptorType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MutableDescriptorTypeListEXT::MutableDescriptorTypeListEXT(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);
+    }
+}
+
+MutableDescriptorTypeListEXT::MutableDescriptorTypeListEXT() : descriptorTypeCount(), pDescriptorTypes(nullptr) {}
+
+MutableDescriptorTypeListEXT::MutableDescriptorTypeListEXT(const MutableDescriptorTypeListEXT& 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);
+    }
+}
+
+MutableDescriptorTypeListEXT& MutableDescriptorTypeListEXT::operator=(const MutableDescriptorTypeListEXT& 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;
+}
+
+MutableDescriptorTypeListEXT::~MutableDescriptorTypeListEXT() {
+    if (pDescriptorTypes) delete[] pDescriptorTypes;
+}
+
+void MutableDescriptorTypeListEXT::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 MutableDescriptorTypeListEXT::initialize(const MutableDescriptorTypeListEXT* 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);
+    }
+}
+
+MutableDescriptorTypeCreateInfoEXT::MutableDescriptorTypeCreateInfoEXT(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 MutableDescriptorTypeListEXT[mutableDescriptorTypeListCount];
+        for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
+            pMutableDescriptorTypeLists[i].initialize(&in_struct->pMutableDescriptorTypeLists[i]);
+        }
+    }
+}
+
+MutableDescriptorTypeCreateInfoEXT::MutableDescriptorTypeCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      mutableDescriptorTypeListCount(),
+      pMutableDescriptorTypeLists(nullptr) {}
+
+MutableDescriptorTypeCreateInfoEXT::MutableDescriptorTypeCreateInfoEXT(const MutableDescriptorTypeCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    mutableDescriptorTypeListCount = copy_src.mutableDescriptorTypeListCount;
+    pMutableDescriptorTypeLists = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (mutableDescriptorTypeListCount && copy_src.pMutableDescriptorTypeLists) {
+        pMutableDescriptorTypeLists = new MutableDescriptorTypeListEXT[mutableDescriptorTypeListCount];
+        for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
+            pMutableDescriptorTypeLists[i].initialize(&copy_src.pMutableDescriptorTypeLists[i]);
+        }
+    }
+}
+
+MutableDescriptorTypeCreateInfoEXT& MutableDescriptorTypeCreateInfoEXT::operator=(
+    const MutableDescriptorTypeCreateInfoEXT& 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 MutableDescriptorTypeListEXT[mutableDescriptorTypeListCount];
+        for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
+            pMutableDescriptorTypeLists[i].initialize(&copy_src.pMutableDescriptorTypeLists[i]);
+        }
+    }
+
+    return *this;
+}
+
+MutableDescriptorTypeCreateInfoEXT::~MutableDescriptorTypeCreateInfoEXT() {
+    if (pMutableDescriptorTypeLists) delete[] pMutableDescriptorTypeLists;
+    FreePnextChain(pNext);
+}
+
+void MutableDescriptorTypeCreateInfoEXT::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 MutableDescriptorTypeListEXT[mutableDescriptorTypeListCount];
+        for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
+            pMutableDescriptorTypeLists[i].initialize(&in_struct->pMutableDescriptorTypeLists[i]);
+        }
+    }
+}
+
+void MutableDescriptorTypeCreateInfoEXT::initialize(const MutableDescriptorTypeCreateInfoEXT* 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 MutableDescriptorTypeListEXT[mutableDescriptorTypeListCount];
+        for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
+            pMutableDescriptorTypeLists[i].initialize(&copy_src->pMutableDescriptorTypeLists[i]);
+        }
+    }
+}
+
+PhysicalDeviceVertexInputDynamicStateFeaturesEXT::PhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceVertexInputDynamicStateFeaturesEXT::PhysicalDeviceVertexInputDynamicStateFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT), pNext(nullptr), vertexInputDynamicState() {}
+
+PhysicalDeviceVertexInputDynamicStateFeaturesEXT::PhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+    const PhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    vertexInputDynamicState = copy_src.vertexInputDynamicState;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceVertexInputDynamicStateFeaturesEXT& PhysicalDeviceVertexInputDynamicStateFeaturesEXT::operator=(
+    const PhysicalDeviceVertexInputDynamicStateFeaturesEXT& 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;
+}
+
+PhysicalDeviceVertexInputDynamicStateFeaturesEXT::~PhysicalDeviceVertexInputDynamicStateFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVertexInputDynamicStateFeaturesEXT::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 PhysicalDeviceVertexInputDynamicStateFeaturesEXT::initialize(const PhysicalDeviceVertexInputDynamicStateFeaturesEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexInputDynamicState = copy_src->vertexInputDynamicState;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VertexInputBindingDescription2EXT::VertexInputBindingDescription2EXT(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);
+    }
+}
+
+VertexInputBindingDescription2EXT::VertexInputBindingDescription2EXT()
+    : sType(VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT),
+      pNext(nullptr),
+      binding(),
+      stride(),
+      inputRate(),
+      divisor() {}
+
+VertexInputBindingDescription2EXT::VertexInputBindingDescription2EXT(const VertexInputBindingDescription2EXT& 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);
+}
+
+VertexInputBindingDescription2EXT& VertexInputBindingDescription2EXT::operator=(const VertexInputBindingDescription2EXT& 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;
+}
+
+VertexInputBindingDescription2EXT::~VertexInputBindingDescription2EXT() { FreePnextChain(pNext); }
+
+void VertexInputBindingDescription2EXT::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 VertexInputBindingDescription2EXT::initialize(const VertexInputBindingDescription2EXT* 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);
+}
+
+VertexInputAttributeDescription2EXT::VertexInputAttributeDescription2EXT(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);
+    }
+}
+
+VertexInputAttributeDescription2EXT::VertexInputAttributeDescription2EXT()
+    : sType(VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT),
+      pNext(nullptr),
+      location(),
+      binding(),
+      format(),
+      offset() {}
+
+VertexInputAttributeDescription2EXT::VertexInputAttributeDescription2EXT(const VertexInputAttributeDescription2EXT& 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);
+}
+
+VertexInputAttributeDescription2EXT& VertexInputAttributeDescription2EXT::operator=(
+    const VertexInputAttributeDescription2EXT& 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;
+}
+
+VertexInputAttributeDescription2EXT::~VertexInputAttributeDescription2EXT() { FreePnextChain(pNext); }
+
+void VertexInputAttributeDescription2EXT::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 VertexInputAttributeDescription2EXT::initialize(const VertexInputAttributeDescription2EXT* 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);
+}
+
+PhysicalDeviceDrmPropertiesEXT::PhysicalDeviceDrmPropertiesEXT(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);
+    }
+}
+
+PhysicalDeviceDrmPropertiesEXT::PhysicalDeviceDrmPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT),
+      pNext(nullptr),
+      hasPrimary(),
+      hasRender(),
+      primaryMajor(),
+      primaryMinor(),
+      renderMajor(),
+      renderMinor() {}
+
+PhysicalDeviceDrmPropertiesEXT::PhysicalDeviceDrmPropertiesEXT(const PhysicalDeviceDrmPropertiesEXT& 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);
+}
+
+PhysicalDeviceDrmPropertiesEXT& PhysicalDeviceDrmPropertiesEXT::operator=(const PhysicalDeviceDrmPropertiesEXT& 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;
+}
+
+PhysicalDeviceDrmPropertiesEXT::~PhysicalDeviceDrmPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDrmPropertiesEXT::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 PhysicalDeviceDrmPropertiesEXT::initialize(const PhysicalDeviceDrmPropertiesEXT* 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);
+}
+
+PhysicalDeviceAddressBindingReportFeaturesEXT::PhysicalDeviceAddressBindingReportFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceAddressBindingReportFeaturesEXT::PhysicalDeviceAddressBindingReportFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT), pNext(nullptr), reportAddressBinding() {}
+
+PhysicalDeviceAddressBindingReportFeaturesEXT::PhysicalDeviceAddressBindingReportFeaturesEXT(
+    const PhysicalDeviceAddressBindingReportFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    reportAddressBinding = copy_src.reportAddressBinding;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceAddressBindingReportFeaturesEXT& PhysicalDeviceAddressBindingReportFeaturesEXT::operator=(
+    const PhysicalDeviceAddressBindingReportFeaturesEXT& 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;
+}
+
+PhysicalDeviceAddressBindingReportFeaturesEXT::~PhysicalDeviceAddressBindingReportFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceAddressBindingReportFeaturesEXT::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 PhysicalDeviceAddressBindingReportFeaturesEXT::initialize(const PhysicalDeviceAddressBindingReportFeaturesEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    reportAddressBinding = copy_src->reportAddressBinding;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DeviceAddressBindingCallbackDataEXT::DeviceAddressBindingCallbackDataEXT(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);
+    }
+}
+
+DeviceAddressBindingCallbackDataEXT::DeviceAddressBindingCallbackDataEXT()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT),
+      pNext(nullptr),
+      flags(),
+      baseAddress(),
+      size(),
+      bindingType() {}
+
+DeviceAddressBindingCallbackDataEXT::DeviceAddressBindingCallbackDataEXT(const DeviceAddressBindingCallbackDataEXT& 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);
+}
+
+DeviceAddressBindingCallbackDataEXT& DeviceAddressBindingCallbackDataEXT::operator=(
+    const DeviceAddressBindingCallbackDataEXT& 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;
+}
+
+DeviceAddressBindingCallbackDataEXT::~DeviceAddressBindingCallbackDataEXT() { FreePnextChain(pNext); }
+
+void DeviceAddressBindingCallbackDataEXT::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 DeviceAddressBindingCallbackDataEXT::initialize(const DeviceAddressBindingCallbackDataEXT* 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);
+}
+
+PhysicalDeviceDepthClipControlFeaturesEXT::PhysicalDeviceDepthClipControlFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceDepthClipControlFeaturesEXT::PhysicalDeviceDepthClipControlFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT), pNext(nullptr), depthClipControl() {}
+
+PhysicalDeviceDepthClipControlFeaturesEXT::PhysicalDeviceDepthClipControlFeaturesEXT(
+    const PhysicalDeviceDepthClipControlFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    depthClipControl = copy_src.depthClipControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDepthClipControlFeaturesEXT& PhysicalDeviceDepthClipControlFeaturesEXT::operator=(
+    const PhysicalDeviceDepthClipControlFeaturesEXT& 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;
+}
+
+PhysicalDeviceDepthClipControlFeaturesEXT::~PhysicalDeviceDepthClipControlFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDepthClipControlFeaturesEXT::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 PhysicalDeviceDepthClipControlFeaturesEXT::initialize(const PhysicalDeviceDepthClipControlFeaturesEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthClipControl = copy_src->depthClipControl;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineViewportDepthClipControlCreateInfoEXT::PipelineViewportDepthClipControlCreateInfoEXT(
+    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);
+    }
+}
+
+PipelineViewportDepthClipControlCreateInfoEXT::PipelineViewportDepthClipControlCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT), pNext(nullptr), negativeOneToOne() {}
+
+PipelineViewportDepthClipControlCreateInfoEXT::PipelineViewportDepthClipControlCreateInfoEXT(
+    const PipelineViewportDepthClipControlCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    negativeOneToOne = copy_src.negativeOneToOne;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineViewportDepthClipControlCreateInfoEXT& PipelineViewportDepthClipControlCreateInfoEXT::operator=(
+    const PipelineViewportDepthClipControlCreateInfoEXT& 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;
+}
+
+PipelineViewportDepthClipControlCreateInfoEXT::~PipelineViewportDepthClipControlCreateInfoEXT() { FreePnextChain(pNext); }
+
+void PipelineViewportDepthClipControlCreateInfoEXT::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 PipelineViewportDepthClipControlCreateInfoEXT::initialize(const PipelineViewportDepthClipControlCreateInfoEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    negativeOneToOne = copy_src->negativeOneToOne;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT),
+      pNext(nullptr),
+      primitiveTopologyListRestart(),
+      primitiveTopologyPatchListRestart() {}
+
+PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+    const PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    primitiveTopologyListRestart = copy_src.primitiveTopologyListRestart;
+    primitiveTopologyPatchListRestart = copy_src.primitiveTopologyPatchListRestart;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::operator=(
+    const PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& 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;
+}
+
+PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::~PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::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 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::initialize(
+    const PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    primitiveTopologyListRestart = copy_src->primitiveTopologyListRestart;
+    primitiveTopologyPatchListRestart = copy_src->primitiveTopologyPatchListRestart;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelinePropertiesIdentifierEXT::PipelinePropertiesIdentifierEXT(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];
+    }
+}
+
+PipelinePropertiesIdentifierEXT::PipelinePropertiesIdentifierEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT), pNext(nullptr) {}
+
+PipelinePropertiesIdentifierEXT::PipelinePropertiesIdentifierEXT(const PipelinePropertiesIdentifierEXT& 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];
+    }
+}
+
+PipelinePropertiesIdentifierEXT& PipelinePropertiesIdentifierEXT::operator=(const PipelinePropertiesIdentifierEXT& 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;
+}
+
+PipelinePropertiesIdentifierEXT::~PipelinePropertiesIdentifierEXT() { FreePnextChain(pNext); }
+
+void PipelinePropertiesIdentifierEXT::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 PipelinePropertiesIdentifierEXT::initialize(const PipelinePropertiesIdentifierEXT* 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];
+    }
+}
+
+PhysicalDevicePipelinePropertiesFeaturesEXT::PhysicalDevicePipelinePropertiesFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDevicePipelinePropertiesFeaturesEXT::PhysicalDevicePipelinePropertiesFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT), pNext(nullptr), pipelinePropertiesIdentifier() {}
+
+PhysicalDevicePipelinePropertiesFeaturesEXT::PhysicalDevicePipelinePropertiesFeaturesEXT(
+    const PhysicalDevicePipelinePropertiesFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    pipelinePropertiesIdentifier = copy_src.pipelinePropertiesIdentifier;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePipelinePropertiesFeaturesEXT& PhysicalDevicePipelinePropertiesFeaturesEXT::operator=(
+    const PhysicalDevicePipelinePropertiesFeaturesEXT& 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;
+}
+
+PhysicalDevicePipelinePropertiesFeaturesEXT::~PhysicalDevicePipelinePropertiesFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDevicePipelinePropertiesFeaturesEXT::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 PhysicalDevicePipelinePropertiesFeaturesEXT::initialize(const PhysicalDevicePipelinePropertiesFeaturesEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelinePropertiesIdentifier = copy_src->pipelinePropertiesIdentifier;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceFrameBoundaryFeaturesEXT::PhysicalDeviceFrameBoundaryFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceFrameBoundaryFeaturesEXT::PhysicalDeviceFrameBoundaryFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT), pNext(nullptr), frameBoundary() {}
+
+PhysicalDeviceFrameBoundaryFeaturesEXT::PhysicalDeviceFrameBoundaryFeaturesEXT(
+    const PhysicalDeviceFrameBoundaryFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    frameBoundary = copy_src.frameBoundary;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFrameBoundaryFeaturesEXT& PhysicalDeviceFrameBoundaryFeaturesEXT::operator=(
+    const PhysicalDeviceFrameBoundaryFeaturesEXT& 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;
+}
+
+PhysicalDeviceFrameBoundaryFeaturesEXT::~PhysicalDeviceFrameBoundaryFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFrameBoundaryFeaturesEXT::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 PhysicalDeviceFrameBoundaryFeaturesEXT::initialize(const PhysicalDeviceFrameBoundaryFeaturesEXT* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    frameBoundary = copy_src->frameBoundary;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+FrameBoundaryEXT::FrameBoundaryEXT(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];
+        }
+    }
+}
+
+FrameBoundaryEXT::FrameBoundaryEXT()
+    : sType(VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT),
+      pNext(nullptr),
+      flags(),
+      frameID(),
+      imageCount(),
+      pImages(nullptr),
+      bufferCount(),
+      pBuffers(nullptr),
+      tagName(),
+      tagSize(),
+      pTag(nullptr) {}
+
+FrameBoundaryEXT::FrameBoundaryEXT(const FrameBoundaryEXT& 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];
+        }
+    }
+}
+
+FrameBoundaryEXT& FrameBoundaryEXT::operator=(const FrameBoundaryEXT& 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;
+}
+
+FrameBoundaryEXT::~FrameBoundaryEXT() {
+    if (pImages) delete[] pImages;
+    if (pBuffers) delete[] pBuffers;
+    FreePnextChain(pNext);
+}
+
+void FrameBoundaryEXT::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 FrameBoundaryEXT::initialize(const FrameBoundaryEXT* 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];
+        }
+    }
+}
+
+PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT),
+      pNext(nullptr),
+      multisampledRenderToSingleSampled() {}
+
+PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    const PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    multisampledRenderToSingleSampled = copy_src.multisampledRenderToSingleSampled;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::operator=(
+    const PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& 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;
+}
+
+PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::~PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::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 PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::initialize(
+    const PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    multisampledRenderToSingleSampled = copy_src->multisampledRenderToSingleSampled;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SubpassResolvePerformanceQueryEXT::SubpassResolvePerformanceQueryEXT(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);
+    }
+}
+
+SubpassResolvePerformanceQueryEXT::SubpassResolvePerformanceQueryEXT()
+    : sType(VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT), pNext(nullptr), optimal() {}
+
+SubpassResolvePerformanceQueryEXT::SubpassResolvePerformanceQueryEXT(const SubpassResolvePerformanceQueryEXT& copy_src) {
+    sType = copy_src.sType;
+    optimal = copy_src.optimal;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SubpassResolvePerformanceQueryEXT& SubpassResolvePerformanceQueryEXT::operator=(const SubpassResolvePerformanceQueryEXT& 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;
+}
+
+SubpassResolvePerformanceQueryEXT::~SubpassResolvePerformanceQueryEXT() { FreePnextChain(pNext); }
+
+void SubpassResolvePerformanceQueryEXT::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 SubpassResolvePerformanceQueryEXT::initialize(const SubpassResolvePerformanceQueryEXT* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    optimal = copy_src->optimal;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MultisampledRenderToSingleSampledInfoEXT::MultisampledRenderToSingleSampledInfoEXT(
+    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);
+    }
+}
+
+MultisampledRenderToSingleSampledInfoEXT::MultisampledRenderToSingleSampledInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT),
+      pNext(nullptr),
+      multisampledRenderToSingleSampledEnable(),
+      rasterizationSamples() {}
+
+MultisampledRenderToSingleSampledInfoEXT::MultisampledRenderToSingleSampledInfoEXT(
+    const MultisampledRenderToSingleSampledInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    multisampledRenderToSingleSampledEnable = copy_src.multisampledRenderToSingleSampledEnable;
+    rasterizationSamples = copy_src.rasterizationSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MultisampledRenderToSingleSampledInfoEXT& MultisampledRenderToSingleSampledInfoEXT::operator=(
+    const MultisampledRenderToSingleSampledInfoEXT& 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;
+}
+
+MultisampledRenderToSingleSampledInfoEXT::~MultisampledRenderToSingleSampledInfoEXT() { FreePnextChain(pNext); }
+
+void MultisampledRenderToSingleSampledInfoEXT::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 MultisampledRenderToSingleSampledInfoEXT::initialize(const MultisampledRenderToSingleSampledInfoEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    multisampledRenderToSingleSampledEnable = copy_src->multisampledRenderToSingleSampledEnable;
+    rasterizationSamples = copy_src->rasterizationSamples;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceExtendedDynamicState2FeaturesEXT::PhysicalDeviceExtendedDynamicState2FeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceExtendedDynamicState2FeaturesEXT::PhysicalDeviceExtendedDynamicState2FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT),
+      pNext(nullptr),
+      extendedDynamicState2(),
+      extendedDynamicState2LogicOp(),
+      extendedDynamicState2PatchControlPoints() {}
+
+PhysicalDeviceExtendedDynamicState2FeaturesEXT::PhysicalDeviceExtendedDynamicState2FeaturesEXT(
+    const PhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    extendedDynamicState2 = copy_src.extendedDynamicState2;
+    extendedDynamicState2LogicOp = copy_src.extendedDynamicState2LogicOp;
+    extendedDynamicState2PatchControlPoints = copy_src.extendedDynamicState2PatchControlPoints;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExtendedDynamicState2FeaturesEXT& PhysicalDeviceExtendedDynamicState2FeaturesEXT::operator=(
+    const PhysicalDeviceExtendedDynamicState2FeaturesEXT& 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;
+}
+
+PhysicalDeviceExtendedDynamicState2FeaturesEXT::~PhysicalDeviceExtendedDynamicState2FeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExtendedDynamicState2FeaturesEXT::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 PhysicalDeviceExtendedDynamicState2FeaturesEXT::initialize(const PhysicalDeviceExtendedDynamicState2FeaturesEXT* 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);
+}
+
+PhysicalDeviceColorWriteEnableFeaturesEXT::PhysicalDeviceColorWriteEnableFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceColorWriteEnableFeaturesEXT::PhysicalDeviceColorWriteEnableFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT), pNext(nullptr), colorWriteEnable() {}
+
+PhysicalDeviceColorWriteEnableFeaturesEXT::PhysicalDeviceColorWriteEnableFeaturesEXT(
+    const PhysicalDeviceColorWriteEnableFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    colorWriteEnable = copy_src.colorWriteEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceColorWriteEnableFeaturesEXT& PhysicalDeviceColorWriteEnableFeaturesEXT::operator=(
+    const PhysicalDeviceColorWriteEnableFeaturesEXT& 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;
+}
+
+PhysicalDeviceColorWriteEnableFeaturesEXT::~PhysicalDeviceColorWriteEnableFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceColorWriteEnableFeaturesEXT::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 PhysicalDeviceColorWriteEnableFeaturesEXT::initialize(const PhysicalDeviceColorWriteEnableFeaturesEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    colorWriteEnable = copy_src->colorWriteEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineColorWriteCreateInfoEXT::PipelineColorWriteCreateInfoEXT(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);
+    }
+}
+
+PipelineColorWriteCreateInfoEXT::PipelineColorWriteCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      attachmentCount(),
+      pColorWriteEnables(nullptr) {}
+
+PipelineColorWriteCreateInfoEXT::PipelineColorWriteCreateInfoEXT(const PipelineColorWriteCreateInfoEXT& 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);
+    }
+}
+
+PipelineColorWriteCreateInfoEXT& PipelineColorWriteCreateInfoEXT::operator=(const PipelineColorWriteCreateInfoEXT& 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;
+}
+
+PipelineColorWriteCreateInfoEXT::~PipelineColorWriteCreateInfoEXT() {
+    if (pColorWriteEnables) delete[] pColorWriteEnables;
+    FreePnextChain(pNext);
+}
+
+void PipelineColorWriteCreateInfoEXT::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 PipelineColorWriteCreateInfoEXT::initialize(const PipelineColorWriteCreateInfoEXT* 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);
+    }
+}
+
+PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT),
+      pNext(nullptr),
+      primitivesGeneratedQuery(),
+      primitivesGeneratedQueryWithRasterizerDiscard(),
+      primitivesGeneratedQueryWithNonZeroStreams() {}
+
+PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    const PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    primitivesGeneratedQuery = copy_src.primitivesGeneratedQuery;
+    primitivesGeneratedQueryWithRasterizerDiscard = copy_src.primitivesGeneratedQueryWithRasterizerDiscard;
+    primitivesGeneratedQueryWithNonZeroStreams = copy_src.primitivesGeneratedQueryWithNonZeroStreams;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::operator=(
+    const PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& 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;
+}
+
+PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::~PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::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 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::initialize(
+    const PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* 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);
+}
+
+PhysicalDeviceImageViewMinLodFeaturesEXT::PhysicalDeviceImageViewMinLodFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceImageViewMinLodFeaturesEXT::PhysicalDeviceImageViewMinLodFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT), pNext(nullptr), minLod() {}
+
+PhysicalDeviceImageViewMinLodFeaturesEXT::PhysicalDeviceImageViewMinLodFeaturesEXT(
+    const PhysicalDeviceImageViewMinLodFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    minLod = copy_src.minLod;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceImageViewMinLodFeaturesEXT& PhysicalDeviceImageViewMinLodFeaturesEXT::operator=(
+    const PhysicalDeviceImageViewMinLodFeaturesEXT& 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;
+}
+
+PhysicalDeviceImageViewMinLodFeaturesEXT::~PhysicalDeviceImageViewMinLodFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImageViewMinLodFeaturesEXT::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 PhysicalDeviceImageViewMinLodFeaturesEXT::initialize(const PhysicalDeviceImageViewMinLodFeaturesEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minLod = copy_src->minLod;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImageViewMinLodCreateInfoEXT::ImageViewMinLodCreateInfoEXT(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);
+    }
+}
+
+ImageViewMinLodCreateInfoEXT::ImageViewMinLodCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT), pNext(nullptr), minLod() {}
+
+ImageViewMinLodCreateInfoEXT::ImageViewMinLodCreateInfoEXT(const ImageViewMinLodCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    minLod = copy_src.minLod;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageViewMinLodCreateInfoEXT& ImageViewMinLodCreateInfoEXT::operator=(const ImageViewMinLodCreateInfoEXT& 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;
+}
+
+ImageViewMinLodCreateInfoEXT::~ImageViewMinLodCreateInfoEXT() { FreePnextChain(pNext); }
+
+void ImageViewMinLodCreateInfoEXT::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 ImageViewMinLodCreateInfoEXT::initialize(const ImageViewMinLodCreateInfoEXT* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minLod = copy_src->minLod;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMultiDrawFeaturesEXT::PhysicalDeviceMultiDrawFeaturesEXT(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);
+    }
+}
+
+PhysicalDeviceMultiDrawFeaturesEXT::PhysicalDeviceMultiDrawFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT), pNext(nullptr), multiDraw() {}
+
+PhysicalDeviceMultiDrawFeaturesEXT::PhysicalDeviceMultiDrawFeaturesEXT(const PhysicalDeviceMultiDrawFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    multiDraw = copy_src.multiDraw;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMultiDrawFeaturesEXT& PhysicalDeviceMultiDrawFeaturesEXT::operator=(
+    const PhysicalDeviceMultiDrawFeaturesEXT& 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;
+}
+
+PhysicalDeviceMultiDrawFeaturesEXT::~PhysicalDeviceMultiDrawFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMultiDrawFeaturesEXT::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 PhysicalDeviceMultiDrawFeaturesEXT::initialize(const PhysicalDeviceMultiDrawFeaturesEXT* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    multiDraw = copy_src->multiDraw;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMultiDrawPropertiesEXT::PhysicalDeviceMultiDrawPropertiesEXT(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);
+    }
+}
+
+PhysicalDeviceMultiDrawPropertiesEXT::PhysicalDeviceMultiDrawPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT), pNext(nullptr), maxMultiDrawCount() {}
+
+PhysicalDeviceMultiDrawPropertiesEXT::PhysicalDeviceMultiDrawPropertiesEXT(const PhysicalDeviceMultiDrawPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxMultiDrawCount = copy_src.maxMultiDrawCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMultiDrawPropertiesEXT& PhysicalDeviceMultiDrawPropertiesEXT::operator=(
+    const PhysicalDeviceMultiDrawPropertiesEXT& 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;
+}
+
+PhysicalDeviceMultiDrawPropertiesEXT::~PhysicalDeviceMultiDrawPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMultiDrawPropertiesEXT::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 PhysicalDeviceMultiDrawPropertiesEXT::initialize(const PhysicalDeviceMultiDrawPropertiesEXT* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxMultiDrawCount = copy_src->maxMultiDrawCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceImage2DViewOf3DFeaturesEXT::PhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceImage2DViewOf3DFeaturesEXT::PhysicalDeviceImage2DViewOf3DFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT),
+      pNext(nullptr),
+      image2DViewOf3D(),
+      sampler2DViewOf3D() {}
+
+PhysicalDeviceImage2DViewOf3DFeaturesEXT::PhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    const PhysicalDeviceImage2DViewOf3DFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    image2DViewOf3D = copy_src.image2DViewOf3D;
+    sampler2DViewOf3D = copy_src.sampler2DViewOf3D;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceImage2DViewOf3DFeaturesEXT& PhysicalDeviceImage2DViewOf3DFeaturesEXT::operator=(
+    const PhysicalDeviceImage2DViewOf3DFeaturesEXT& 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;
+}
+
+PhysicalDeviceImage2DViewOf3DFeaturesEXT::~PhysicalDeviceImage2DViewOf3DFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImage2DViewOf3DFeaturesEXT::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 PhysicalDeviceImage2DViewOf3DFeaturesEXT::initialize(const PhysicalDeviceImage2DViewOf3DFeaturesEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image2DViewOf3D = copy_src->image2DViewOf3D;
+    sampler2DViewOf3D = copy_src->sampler2DViewOf3D;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderTileImageFeaturesEXT::PhysicalDeviceShaderTileImageFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceShaderTileImageFeaturesEXT::PhysicalDeviceShaderTileImageFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT),
+      pNext(nullptr),
+      shaderTileImageColorReadAccess(),
+      shaderTileImageDepthReadAccess(),
+      shaderTileImageStencilReadAccess() {}
+
+PhysicalDeviceShaderTileImageFeaturesEXT::PhysicalDeviceShaderTileImageFeaturesEXT(
+    const PhysicalDeviceShaderTileImageFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderTileImageColorReadAccess = copy_src.shaderTileImageColorReadAccess;
+    shaderTileImageDepthReadAccess = copy_src.shaderTileImageDepthReadAccess;
+    shaderTileImageStencilReadAccess = copy_src.shaderTileImageStencilReadAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderTileImageFeaturesEXT& PhysicalDeviceShaderTileImageFeaturesEXT::operator=(
+    const PhysicalDeviceShaderTileImageFeaturesEXT& 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;
+}
+
+PhysicalDeviceShaderTileImageFeaturesEXT::~PhysicalDeviceShaderTileImageFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderTileImageFeaturesEXT::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 PhysicalDeviceShaderTileImageFeaturesEXT::initialize(const PhysicalDeviceShaderTileImageFeaturesEXT* 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);
+}
+
+PhysicalDeviceShaderTileImagePropertiesEXT::PhysicalDeviceShaderTileImagePropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceShaderTileImagePropertiesEXT::PhysicalDeviceShaderTileImagePropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT),
+      pNext(nullptr),
+      shaderTileImageCoherentReadAccelerated(),
+      shaderTileImageReadSampleFromPixelRateInvocation(),
+      shaderTileImageReadFromHelperInvocation() {}
+
+PhysicalDeviceShaderTileImagePropertiesEXT::PhysicalDeviceShaderTileImagePropertiesEXT(
+    const PhysicalDeviceShaderTileImagePropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderTileImageCoherentReadAccelerated = copy_src.shaderTileImageCoherentReadAccelerated;
+    shaderTileImageReadSampleFromPixelRateInvocation = copy_src.shaderTileImageReadSampleFromPixelRateInvocation;
+    shaderTileImageReadFromHelperInvocation = copy_src.shaderTileImageReadFromHelperInvocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderTileImagePropertiesEXT& PhysicalDeviceShaderTileImagePropertiesEXT::operator=(
+    const PhysicalDeviceShaderTileImagePropertiesEXT& 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;
+}
+
+PhysicalDeviceShaderTileImagePropertiesEXT::~PhysicalDeviceShaderTileImagePropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderTileImagePropertiesEXT::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 PhysicalDeviceShaderTileImagePropertiesEXT::initialize(const PhysicalDeviceShaderTileImagePropertiesEXT* 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);
+}
+
+MicromapCreateInfoEXT::MicromapCreateInfoEXT(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);
+    }
+}
+
+MicromapCreateInfoEXT::MicromapCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT),
+      pNext(nullptr),
+      createFlags(),
+      buffer(),
+      offset(),
+      size(),
+      type(),
+      deviceAddress() {}
+
+MicromapCreateInfoEXT::MicromapCreateInfoEXT(const MicromapCreateInfoEXT& 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);
+}
+
+MicromapCreateInfoEXT& MicromapCreateInfoEXT::operator=(const MicromapCreateInfoEXT& 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;
+}
+
+MicromapCreateInfoEXT::~MicromapCreateInfoEXT() { FreePnextChain(pNext); }
+
+void MicromapCreateInfoEXT::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 MicromapCreateInfoEXT::initialize(const MicromapCreateInfoEXT* 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);
+}
+
+PhysicalDeviceOpacityMicromapFeaturesEXT::PhysicalDeviceOpacityMicromapFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceOpacityMicromapFeaturesEXT::PhysicalDeviceOpacityMicromapFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT),
+      pNext(nullptr),
+      micromap(),
+      micromapCaptureReplay(),
+      micromapHostCommands() {}
+
+PhysicalDeviceOpacityMicromapFeaturesEXT::PhysicalDeviceOpacityMicromapFeaturesEXT(
+    const PhysicalDeviceOpacityMicromapFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    micromap = copy_src.micromap;
+    micromapCaptureReplay = copy_src.micromapCaptureReplay;
+    micromapHostCommands = copy_src.micromapHostCommands;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceOpacityMicromapFeaturesEXT& PhysicalDeviceOpacityMicromapFeaturesEXT::operator=(
+    const PhysicalDeviceOpacityMicromapFeaturesEXT& 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;
+}
+
+PhysicalDeviceOpacityMicromapFeaturesEXT::~PhysicalDeviceOpacityMicromapFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceOpacityMicromapFeaturesEXT::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 PhysicalDeviceOpacityMicromapFeaturesEXT::initialize(const PhysicalDeviceOpacityMicromapFeaturesEXT* 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);
+}
+
+PhysicalDeviceOpacityMicromapPropertiesEXT::PhysicalDeviceOpacityMicromapPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceOpacityMicromapPropertiesEXT::PhysicalDeviceOpacityMicromapPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT),
+      pNext(nullptr),
+      maxOpacity2StateSubdivisionLevel(),
+      maxOpacity4StateSubdivisionLevel() {}
+
+PhysicalDeviceOpacityMicromapPropertiesEXT::PhysicalDeviceOpacityMicromapPropertiesEXT(
+    const PhysicalDeviceOpacityMicromapPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxOpacity2StateSubdivisionLevel = copy_src.maxOpacity2StateSubdivisionLevel;
+    maxOpacity4StateSubdivisionLevel = copy_src.maxOpacity4StateSubdivisionLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceOpacityMicromapPropertiesEXT& PhysicalDeviceOpacityMicromapPropertiesEXT::operator=(
+    const PhysicalDeviceOpacityMicromapPropertiesEXT& 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;
+}
+
+PhysicalDeviceOpacityMicromapPropertiesEXT::~PhysicalDeviceOpacityMicromapPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceOpacityMicromapPropertiesEXT::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 PhysicalDeviceOpacityMicromapPropertiesEXT::initialize(const PhysicalDeviceOpacityMicromapPropertiesEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxOpacity2StateSubdivisionLevel = copy_src->maxOpacity2StateSubdivisionLevel;
+    maxOpacity4StateSubdivisionLevel = copy_src->maxOpacity4StateSubdivisionLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MicromapVersionInfoEXT::MicromapVersionInfoEXT(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);
+    }
+}
+
+MicromapVersionInfoEXT::MicromapVersionInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT), pNext(nullptr), pVersionData(nullptr) {}
+
+MicromapVersionInfoEXT::MicromapVersionInfoEXT(const MicromapVersionInfoEXT& 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);
+    }
+}
+
+MicromapVersionInfoEXT& MicromapVersionInfoEXT::operator=(const MicromapVersionInfoEXT& 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;
+}
+
+MicromapVersionInfoEXT::~MicromapVersionInfoEXT() {
+    if (pVersionData) delete[] pVersionData;
+    FreePnextChain(pNext);
+}
+
+void MicromapVersionInfoEXT::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 MicromapVersionInfoEXT::initialize(const MicromapVersionInfoEXT* 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);
+    }
+}
+
+CopyMicromapToMemoryInfoEXT::CopyMicromapToMemoryInfoEXT(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);
+    }
+}
+
+CopyMicromapToMemoryInfoEXT::CopyMicromapToMemoryInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT), pNext(nullptr), src(), mode() {}
+
+CopyMicromapToMemoryInfoEXT::CopyMicromapToMemoryInfoEXT(const CopyMicromapToMemoryInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst.initialize(&copy_src.dst);
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CopyMicromapToMemoryInfoEXT& CopyMicromapToMemoryInfoEXT::operator=(const CopyMicromapToMemoryInfoEXT& 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;
+}
+
+CopyMicromapToMemoryInfoEXT::~CopyMicromapToMemoryInfoEXT() { FreePnextChain(pNext); }
+
+void CopyMicromapToMemoryInfoEXT::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 CopyMicromapToMemoryInfoEXT::initialize(const CopyMicromapToMemoryInfoEXT* 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);
+}
+
+CopyMemoryToMicromapInfoEXT::CopyMemoryToMicromapInfoEXT(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);
+    }
+}
+
+CopyMemoryToMicromapInfoEXT::CopyMemoryToMicromapInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT), pNext(nullptr), dst(), mode() {}
+
+CopyMemoryToMicromapInfoEXT::CopyMemoryToMicromapInfoEXT(const CopyMemoryToMicromapInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    src.initialize(&copy_src.src);
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CopyMemoryToMicromapInfoEXT& CopyMemoryToMicromapInfoEXT::operator=(const CopyMemoryToMicromapInfoEXT& 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;
+}
+
+CopyMemoryToMicromapInfoEXT::~CopyMemoryToMicromapInfoEXT() { FreePnextChain(pNext); }
+
+void CopyMemoryToMicromapInfoEXT::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 CopyMemoryToMicromapInfoEXT::initialize(const CopyMemoryToMicromapInfoEXT* 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);
+}
+
+CopyMicromapInfoEXT::CopyMicromapInfoEXT(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);
+    }
+}
+
+CopyMicromapInfoEXT::CopyMicromapInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT), pNext(nullptr), src(), dst(), mode() {}
+
+CopyMicromapInfoEXT::CopyMicromapInfoEXT(const CopyMicromapInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CopyMicromapInfoEXT& CopyMicromapInfoEXT::operator=(const CopyMicromapInfoEXT& 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;
+}
+
+CopyMicromapInfoEXT::~CopyMicromapInfoEXT() { FreePnextChain(pNext); }
+
+void CopyMicromapInfoEXT::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 CopyMicromapInfoEXT::initialize(const CopyMicromapInfoEXT* 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);
+}
+
+MicromapBuildSizesInfoEXT::MicromapBuildSizesInfoEXT(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);
+    }
+}
+
+MicromapBuildSizesInfoEXT::MicromapBuildSizesInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT), pNext(nullptr), micromapSize(), buildScratchSize(), discardable() {}
+
+MicromapBuildSizesInfoEXT::MicromapBuildSizesInfoEXT(const MicromapBuildSizesInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    micromapSize = copy_src.micromapSize;
+    buildScratchSize = copy_src.buildScratchSize;
+    discardable = copy_src.discardable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MicromapBuildSizesInfoEXT& MicromapBuildSizesInfoEXT::operator=(const MicromapBuildSizesInfoEXT& 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;
+}
+
+MicromapBuildSizesInfoEXT::~MicromapBuildSizesInfoEXT() { FreePnextChain(pNext); }
+
+void MicromapBuildSizesInfoEXT::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 MicromapBuildSizesInfoEXT::initialize(const MicromapBuildSizesInfoEXT* 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);
+}
+
+PhysicalDeviceBorderColorSwizzleFeaturesEXT::PhysicalDeviceBorderColorSwizzleFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceBorderColorSwizzleFeaturesEXT::PhysicalDeviceBorderColorSwizzleFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT),
+      pNext(nullptr),
+      borderColorSwizzle(),
+      borderColorSwizzleFromImage() {}
+
+PhysicalDeviceBorderColorSwizzleFeaturesEXT::PhysicalDeviceBorderColorSwizzleFeaturesEXT(
+    const PhysicalDeviceBorderColorSwizzleFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    borderColorSwizzle = copy_src.borderColorSwizzle;
+    borderColorSwizzleFromImage = copy_src.borderColorSwizzleFromImage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceBorderColorSwizzleFeaturesEXT& PhysicalDeviceBorderColorSwizzleFeaturesEXT::operator=(
+    const PhysicalDeviceBorderColorSwizzleFeaturesEXT& 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;
+}
+
+PhysicalDeviceBorderColorSwizzleFeaturesEXT::~PhysicalDeviceBorderColorSwizzleFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceBorderColorSwizzleFeaturesEXT::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 PhysicalDeviceBorderColorSwizzleFeaturesEXT::initialize(const PhysicalDeviceBorderColorSwizzleFeaturesEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    borderColorSwizzle = copy_src->borderColorSwizzle;
+    borderColorSwizzleFromImage = copy_src->borderColorSwizzleFromImage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SamplerBorderColorComponentMappingCreateInfoEXT::SamplerBorderColorComponentMappingCreateInfoEXT(
+    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);
+    }
+}
+
+SamplerBorderColorComponentMappingCreateInfoEXT::SamplerBorderColorComponentMappingCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT), pNext(nullptr), components(), srgb() {}
+
+SamplerBorderColorComponentMappingCreateInfoEXT::SamplerBorderColorComponentMappingCreateInfoEXT(
+    const SamplerBorderColorComponentMappingCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    components = copy_src.components;
+    srgb = copy_src.srgb;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SamplerBorderColorComponentMappingCreateInfoEXT& SamplerBorderColorComponentMappingCreateInfoEXT::operator=(
+    const SamplerBorderColorComponentMappingCreateInfoEXT& 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;
+}
+
+SamplerBorderColorComponentMappingCreateInfoEXT::~SamplerBorderColorComponentMappingCreateInfoEXT() { FreePnextChain(pNext); }
+
+void SamplerBorderColorComponentMappingCreateInfoEXT::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 SamplerBorderColorComponentMappingCreateInfoEXT::initialize(const SamplerBorderColorComponentMappingCreateInfoEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    components = copy_src->components;
+    srgb = copy_src->srgb;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT),
+      pNext(nullptr),
+      pageableDeviceLocalMemory() {}
+
+PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+    const PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    pageableDeviceLocalMemory = copy_src.pageableDeviceLocalMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::operator=(
+    const PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& 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;
+}
+
+PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::~PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::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 PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::initialize(
+    const PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pageableDeviceLocalMemory = copy_src->pageableDeviceLocalMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceImageSlicedViewOf3DFeaturesEXT::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceImageSlicedViewOf3DFeaturesEXT::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT), pNext(nullptr), imageSlicedViewOf3D() {}
+
+PhysicalDeviceImageSlicedViewOf3DFeaturesEXT::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    const PhysicalDeviceImageSlicedViewOf3DFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    imageSlicedViewOf3D = copy_src.imageSlicedViewOf3D;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceImageSlicedViewOf3DFeaturesEXT& PhysicalDeviceImageSlicedViewOf3DFeaturesEXT::operator=(
+    const PhysicalDeviceImageSlicedViewOf3DFeaturesEXT& 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;
+}
+
+PhysicalDeviceImageSlicedViewOf3DFeaturesEXT::~PhysicalDeviceImageSlicedViewOf3DFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImageSlicedViewOf3DFeaturesEXT::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 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT::initialize(const PhysicalDeviceImageSlicedViewOf3DFeaturesEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageSlicedViewOf3D = copy_src->imageSlicedViewOf3D;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImageViewSlicedCreateInfoEXT::ImageViewSlicedCreateInfoEXT(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);
+    }
+}
+
+ImageViewSlicedCreateInfoEXT::ImageViewSlicedCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT), pNext(nullptr), sliceOffset(), sliceCount() {}
+
+ImageViewSlicedCreateInfoEXT::ImageViewSlicedCreateInfoEXT(const ImageViewSlicedCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    sliceOffset = copy_src.sliceOffset;
+    sliceCount = copy_src.sliceCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageViewSlicedCreateInfoEXT& ImageViewSlicedCreateInfoEXT::operator=(const ImageViewSlicedCreateInfoEXT& 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;
+}
+
+ImageViewSlicedCreateInfoEXT::~ImageViewSlicedCreateInfoEXT() { FreePnextChain(pNext); }
+
+void ImageViewSlicedCreateInfoEXT::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 ImageViewSlicedCreateInfoEXT::initialize(const ImageViewSlicedCreateInfoEXT* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    sliceOffset = copy_src->sliceOffset;
+    sliceCount = copy_src->sliceCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDepthClampZeroOneFeaturesEXT::PhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceDepthClampZeroOneFeaturesEXT::PhysicalDeviceDepthClampZeroOneFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT), pNext(nullptr), depthClampZeroOne() {}
+
+PhysicalDeviceDepthClampZeroOneFeaturesEXT::PhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    const PhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    depthClampZeroOne = copy_src.depthClampZeroOne;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDepthClampZeroOneFeaturesEXT& PhysicalDeviceDepthClampZeroOneFeaturesEXT::operator=(
+    const PhysicalDeviceDepthClampZeroOneFeaturesEXT& 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;
+}
+
+PhysicalDeviceDepthClampZeroOneFeaturesEXT::~PhysicalDeviceDepthClampZeroOneFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDepthClampZeroOneFeaturesEXT::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 PhysicalDeviceDepthClampZeroOneFeaturesEXT::initialize(const PhysicalDeviceDepthClampZeroOneFeaturesEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthClampZeroOne = copy_src->depthClampZeroOne;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceNonSeamlessCubeMapFeaturesEXT::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceNonSeamlessCubeMapFeaturesEXT::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT), pNext(nullptr), nonSeamlessCubeMap() {}
+
+PhysicalDeviceNonSeamlessCubeMapFeaturesEXT::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    const PhysicalDeviceNonSeamlessCubeMapFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    nonSeamlessCubeMap = copy_src.nonSeamlessCubeMap;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceNonSeamlessCubeMapFeaturesEXT& PhysicalDeviceNonSeamlessCubeMapFeaturesEXT::operator=(
+    const PhysicalDeviceNonSeamlessCubeMapFeaturesEXT& 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;
+}
+
+PhysicalDeviceNonSeamlessCubeMapFeaturesEXT::~PhysicalDeviceNonSeamlessCubeMapFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceNonSeamlessCubeMapFeaturesEXT::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 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT::initialize(const PhysicalDeviceNonSeamlessCubeMapFeaturesEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    nonSeamlessCubeMap = copy_src->nonSeamlessCubeMap;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT),
+      pNext(nullptr),
+      imageCompressionControlSwapchain() {}
+
+PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    const PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    imageCompressionControlSwapchain = copy_src.imageCompressionControlSwapchain;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::operator=(
+    const PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& 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;
+}
+
+PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::~PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::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 PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::initialize(
+    const PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageCompressionControlSwapchain = copy_src->imageCompressionControlSwapchain;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceNestedCommandBufferFeaturesEXT::PhysicalDeviceNestedCommandBufferFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceNestedCommandBufferFeaturesEXT::PhysicalDeviceNestedCommandBufferFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT),
+      pNext(nullptr),
+      nestedCommandBuffer(),
+      nestedCommandBufferRendering(),
+      nestedCommandBufferSimultaneousUse() {}
+
+PhysicalDeviceNestedCommandBufferFeaturesEXT::PhysicalDeviceNestedCommandBufferFeaturesEXT(
+    const PhysicalDeviceNestedCommandBufferFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    nestedCommandBuffer = copy_src.nestedCommandBuffer;
+    nestedCommandBufferRendering = copy_src.nestedCommandBufferRendering;
+    nestedCommandBufferSimultaneousUse = copy_src.nestedCommandBufferSimultaneousUse;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceNestedCommandBufferFeaturesEXT& PhysicalDeviceNestedCommandBufferFeaturesEXT::operator=(
+    const PhysicalDeviceNestedCommandBufferFeaturesEXT& 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;
+}
+
+PhysicalDeviceNestedCommandBufferFeaturesEXT::~PhysicalDeviceNestedCommandBufferFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceNestedCommandBufferFeaturesEXT::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 PhysicalDeviceNestedCommandBufferFeaturesEXT::initialize(const PhysicalDeviceNestedCommandBufferFeaturesEXT* 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);
+}
+
+PhysicalDeviceNestedCommandBufferPropertiesEXT::PhysicalDeviceNestedCommandBufferPropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceNestedCommandBufferPropertiesEXT::PhysicalDeviceNestedCommandBufferPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT),
+      pNext(nullptr),
+      maxCommandBufferNestingLevel() {}
+
+PhysicalDeviceNestedCommandBufferPropertiesEXT::PhysicalDeviceNestedCommandBufferPropertiesEXT(
+    const PhysicalDeviceNestedCommandBufferPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxCommandBufferNestingLevel = copy_src.maxCommandBufferNestingLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceNestedCommandBufferPropertiesEXT& PhysicalDeviceNestedCommandBufferPropertiesEXT::operator=(
+    const PhysicalDeviceNestedCommandBufferPropertiesEXT& 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;
+}
+
+PhysicalDeviceNestedCommandBufferPropertiesEXT::~PhysicalDeviceNestedCommandBufferPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceNestedCommandBufferPropertiesEXT::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 PhysicalDeviceNestedCommandBufferPropertiesEXT::initialize(const PhysicalDeviceNestedCommandBufferPropertiesEXT* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxCommandBufferNestingLevel = copy_src->maxCommandBufferNestingLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExternalMemoryAcquireUnmodifiedEXT::ExternalMemoryAcquireUnmodifiedEXT(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);
+    }
+}
+
+ExternalMemoryAcquireUnmodifiedEXT::ExternalMemoryAcquireUnmodifiedEXT()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT), pNext(nullptr), acquireUnmodifiedMemory() {}
+
+ExternalMemoryAcquireUnmodifiedEXT::ExternalMemoryAcquireUnmodifiedEXT(const ExternalMemoryAcquireUnmodifiedEXT& copy_src) {
+    sType = copy_src.sType;
+    acquireUnmodifiedMemory = copy_src.acquireUnmodifiedMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExternalMemoryAcquireUnmodifiedEXT& ExternalMemoryAcquireUnmodifiedEXT::operator=(
+    const ExternalMemoryAcquireUnmodifiedEXT& 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;
+}
+
+ExternalMemoryAcquireUnmodifiedEXT::~ExternalMemoryAcquireUnmodifiedEXT() { FreePnextChain(pNext); }
+
+void ExternalMemoryAcquireUnmodifiedEXT::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 ExternalMemoryAcquireUnmodifiedEXT::initialize(const ExternalMemoryAcquireUnmodifiedEXT* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    acquireUnmodifiedMemory = copy_src->acquireUnmodifiedMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceExtendedDynamicState3FeaturesEXT::PhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceExtendedDynamicState3FeaturesEXT::PhysicalDeviceExtendedDynamicState3FeaturesEXT()
+    : 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() {}
+
+PhysicalDeviceExtendedDynamicState3FeaturesEXT::PhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    const PhysicalDeviceExtendedDynamicState3FeaturesEXT& 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);
+}
+
+PhysicalDeviceExtendedDynamicState3FeaturesEXT& PhysicalDeviceExtendedDynamicState3FeaturesEXT::operator=(
+    const PhysicalDeviceExtendedDynamicState3FeaturesEXT& 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;
+}
+
+PhysicalDeviceExtendedDynamicState3FeaturesEXT::~PhysicalDeviceExtendedDynamicState3FeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExtendedDynamicState3FeaturesEXT::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 PhysicalDeviceExtendedDynamicState3FeaturesEXT::initialize(const PhysicalDeviceExtendedDynamicState3FeaturesEXT* 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);
+}
+
+PhysicalDeviceExtendedDynamicState3PropertiesEXT::PhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceExtendedDynamicState3PropertiesEXT::PhysicalDeviceExtendedDynamicState3PropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT),
+      pNext(nullptr),
+      dynamicPrimitiveTopologyUnrestricted() {}
+
+PhysicalDeviceExtendedDynamicState3PropertiesEXT::PhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    const PhysicalDeviceExtendedDynamicState3PropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    dynamicPrimitiveTopologyUnrestricted = copy_src.dynamicPrimitiveTopologyUnrestricted;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExtendedDynamicState3PropertiesEXT& PhysicalDeviceExtendedDynamicState3PropertiesEXT::operator=(
+    const PhysicalDeviceExtendedDynamicState3PropertiesEXT& 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;
+}
+
+PhysicalDeviceExtendedDynamicState3PropertiesEXT::~PhysicalDeviceExtendedDynamicState3PropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExtendedDynamicState3PropertiesEXT::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 PhysicalDeviceExtendedDynamicState3PropertiesEXT::initialize(const PhysicalDeviceExtendedDynamicState3PropertiesEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dynamicPrimitiveTopologyUnrestricted = copy_src->dynamicPrimitiveTopologyUnrestricted;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceSubpassMergeFeedbackFeaturesEXT::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceSubpassMergeFeedbackFeaturesEXT::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT), pNext(nullptr), subpassMergeFeedback() {}
+
+PhysicalDeviceSubpassMergeFeedbackFeaturesEXT::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    const PhysicalDeviceSubpassMergeFeedbackFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    subpassMergeFeedback = copy_src.subpassMergeFeedback;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSubpassMergeFeedbackFeaturesEXT& PhysicalDeviceSubpassMergeFeedbackFeaturesEXT::operator=(
+    const PhysicalDeviceSubpassMergeFeedbackFeaturesEXT& 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;
+}
+
+PhysicalDeviceSubpassMergeFeedbackFeaturesEXT::~PhysicalDeviceSubpassMergeFeedbackFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSubpassMergeFeedbackFeaturesEXT::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 PhysicalDeviceSubpassMergeFeedbackFeaturesEXT::initialize(const PhysicalDeviceSubpassMergeFeedbackFeaturesEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subpassMergeFeedback = copy_src->subpassMergeFeedback;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+RenderPassCreationControlEXT::RenderPassCreationControlEXT(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);
+    }
+}
+
+RenderPassCreationControlEXT::RenderPassCreationControlEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT), pNext(nullptr), disallowMerging() {}
+
+RenderPassCreationControlEXT::RenderPassCreationControlEXT(const RenderPassCreationControlEXT& copy_src) {
+    sType = copy_src.sType;
+    disallowMerging = copy_src.disallowMerging;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+RenderPassCreationControlEXT& RenderPassCreationControlEXT::operator=(const RenderPassCreationControlEXT& 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;
+}
+
+RenderPassCreationControlEXT::~RenderPassCreationControlEXT() { FreePnextChain(pNext); }
+
+void RenderPassCreationControlEXT::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 RenderPassCreationControlEXT::initialize(const RenderPassCreationControlEXT* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    disallowMerging = copy_src->disallowMerging;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+RenderPassCreationFeedbackCreateInfoEXT::RenderPassCreationFeedbackCreateInfoEXT(
+    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);
+    }
+}
+
+RenderPassCreationFeedbackCreateInfoEXT::RenderPassCreationFeedbackCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT), pNext(nullptr), pRenderPassFeedback(nullptr) {}
+
+RenderPassCreationFeedbackCreateInfoEXT::RenderPassCreationFeedbackCreateInfoEXT(
+    const RenderPassCreationFeedbackCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pRenderPassFeedback = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pRenderPassFeedback) {
+        pRenderPassFeedback = new VkRenderPassCreationFeedbackInfoEXT(*copy_src.pRenderPassFeedback);
+    }
+}
+
+RenderPassCreationFeedbackCreateInfoEXT& RenderPassCreationFeedbackCreateInfoEXT::operator=(
+    const RenderPassCreationFeedbackCreateInfoEXT& 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;
+}
+
+RenderPassCreationFeedbackCreateInfoEXT::~RenderPassCreationFeedbackCreateInfoEXT() {
+    if (pRenderPassFeedback) delete pRenderPassFeedback;
+    FreePnextChain(pNext);
+}
+
+void RenderPassCreationFeedbackCreateInfoEXT::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 RenderPassCreationFeedbackCreateInfoEXT::initialize(const RenderPassCreationFeedbackCreateInfoEXT* 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);
+    }
+}
+
+RenderPassSubpassFeedbackCreateInfoEXT::RenderPassSubpassFeedbackCreateInfoEXT(
+    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);
+    }
+}
+
+RenderPassSubpassFeedbackCreateInfoEXT::RenderPassSubpassFeedbackCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT), pNext(nullptr), pSubpassFeedback(nullptr) {}
+
+RenderPassSubpassFeedbackCreateInfoEXT::RenderPassSubpassFeedbackCreateInfoEXT(
+    const RenderPassSubpassFeedbackCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pSubpassFeedback = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pSubpassFeedback) {
+        pSubpassFeedback = new VkRenderPassSubpassFeedbackInfoEXT(*copy_src.pSubpassFeedback);
+    }
+}
+
+RenderPassSubpassFeedbackCreateInfoEXT& RenderPassSubpassFeedbackCreateInfoEXT::operator=(
+    const RenderPassSubpassFeedbackCreateInfoEXT& 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;
+}
+
+RenderPassSubpassFeedbackCreateInfoEXT::~RenderPassSubpassFeedbackCreateInfoEXT() {
+    if (pSubpassFeedback) delete pSubpassFeedback;
+    FreePnextChain(pNext);
+}
+
+void RenderPassSubpassFeedbackCreateInfoEXT::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 RenderPassSubpassFeedbackCreateInfoEXT::initialize(const RenderPassSubpassFeedbackCreateInfoEXT* 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);
+    }
+}
+
+PhysicalDeviceShaderModuleIdentifierFeaturesEXT::PhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceShaderModuleIdentifierFeaturesEXT::PhysicalDeviceShaderModuleIdentifierFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT), pNext(nullptr), shaderModuleIdentifier() {}
+
+PhysicalDeviceShaderModuleIdentifierFeaturesEXT::PhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    const PhysicalDeviceShaderModuleIdentifierFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderModuleIdentifier = copy_src.shaderModuleIdentifier;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderModuleIdentifierFeaturesEXT& PhysicalDeviceShaderModuleIdentifierFeaturesEXT::operator=(
+    const PhysicalDeviceShaderModuleIdentifierFeaturesEXT& 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;
+}
+
+PhysicalDeviceShaderModuleIdentifierFeaturesEXT::~PhysicalDeviceShaderModuleIdentifierFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderModuleIdentifierFeaturesEXT::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 PhysicalDeviceShaderModuleIdentifierFeaturesEXT::initialize(const PhysicalDeviceShaderModuleIdentifierFeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderModuleIdentifier = copy_src->shaderModuleIdentifier;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderModuleIdentifierPropertiesEXT::PhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    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];
+    }
+}
+
+PhysicalDeviceShaderModuleIdentifierPropertiesEXT::PhysicalDeviceShaderModuleIdentifierPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT), pNext(nullptr) {}
+
+PhysicalDeviceShaderModuleIdentifierPropertiesEXT::PhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    const PhysicalDeviceShaderModuleIdentifierPropertiesEXT& 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];
+    }
+}
+
+PhysicalDeviceShaderModuleIdentifierPropertiesEXT& PhysicalDeviceShaderModuleIdentifierPropertiesEXT::operator=(
+    const PhysicalDeviceShaderModuleIdentifierPropertiesEXT& 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;
+}
+
+PhysicalDeviceShaderModuleIdentifierPropertiesEXT::~PhysicalDeviceShaderModuleIdentifierPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderModuleIdentifierPropertiesEXT::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 PhysicalDeviceShaderModuleIdentifierPropertiesEXT::initialize(
+    const PhysicalDeviceShaderModuleIdentifierPropertiesEXT* 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];
+    }
+}
+
+PipelineShaderStageModuleIdentifierCreateInfoEXT::PipelineShaderStageModuleIdentifierCreateInfoEXT(
+    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);
+    }
+}
+
+PipelineShaderStageModuleIdentifierCreateInfoEXT::PipelineShaderStageModuleIdentifierCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT),
+      pNext(nullptr),
+      identifierSize(),
+      pIdentifier(nullptr) {}
+
+PipelineShaderStageModuleIdentifierCreateInfoEXT::PipelineShaderStageModuleIdentifierCreateInfoEXT(
+    const PipelineShaderStageModuleIdentifierCreateInfoEXT& 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);
+    }
+}
+
+PipelineShaderStageModuleIdentifierCreateInfoEXT& PipelineShaderStageModuleIdentifierCreateInfoEXT::operator=(
+    const PipelineShaderStageModuleIdentifierCreateInfoEXT& 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;
+}
+
+PipelineShaderStageModuleIdentifierCreateInfoEXT::~PipelineShaderStageModuleIdentifierCreateInfoEXT() {
+    if (pIdentifier) delete[] pIdentifier;
+    FreePnextChain(pNext);
+}
+
+void PipelineShaderStageModuleIdentifierCreateInfoEXT::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 PipelineShaderStageModuleIdentifierCreateInfoEXT::initialize(const PipelineShaderStageModuleIdentifierCreateInfoEXT* 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);
+    }
+}
+
+ShaderModuleIdentifierEXT::ShaderModuleIdentifierEXT(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];
+    }
+}
+
+ShaderModuleIdentifierEXT::ShaderModuleIdentifierEXT()
+    : sType(VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT), pNext(nullptr), identifierSize() {}
+
+ShaderModuleIdentifierEXT::ShaderModuleIdentifierEXT(const ShaderModuleIdentifierEXT& 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];
+    }
+}
+
+ShaderModuleIdentifierEXT& ShaderModuleIdentifierEXT::operator=(const ShaderModuleIdentifierEXT& 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;
+}
+
+ShaderModuleIdentifierEXT::~ShaderModuleIdentifierEXT() { FreePnextChain(pNext); }
+
+void ShaderModuleIdentifierEXT::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 ShaderModuleIdentifierEXT::initialize(const ShaderModuleIdentifierEXT* 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];
+    }
+}
+
+PhysicalDeviceLegacyDitheringFeaturesEXT::PhysicalDeviceLegacyDitheringFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceLegacyDitheringFeaturesEXT::PhysicalDeviceLegacyDitheringFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT), pNext(nullptr), legacyDithering() {}
+
+PhysicalDeviceLegacyDitheringFeaturesEXT::PhysicalDeviceLegacyDitheringFeaturesEXT(
+    const PhysicalDeviceLegacyDitheringFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    legacyDithering = copy_src.legacyDithering;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceLegacyDitheringFeaturesEXT& PhysicalDeviceLegacyDitheringFeaturesEXT::operator=(
+    const PhysicalDeviceLegacyDitheringFeaturesEXT& 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;
+}
+
+PhysicalDeviceLegacyDitheringFeaturesEXT::~PhysicalDeviceLegacyDitheringFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceLegacyDitheringFeaturesEXT::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 PhysicalDeviceLegacyDitheringFeaturesEXT::initialize(const PhysicalDeviceLegacyDitheringFeaturesEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    legacyDithering = copy_src->legacyDithering;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePipelineProtectedAccessFeaturesEXT::PhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDevicePipelineProtectedAccessFeaturesEXT::PhysicalDevicePipelineProtectedAccessFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT), pNext(nullptr), pipelineProtectedAccess() {}
+
+PhysicalDevicePipelineProtectedAccessFeaturesEXT::PhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    const PhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    pipelineProtectedAccess = copy_src.pipelineProtectedAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePipelineProtectedAccessFeaturesEXT& PhysicalDevicePipelineProtectedAccessFeaturesEXT::operator=(
+    const PhysicalDevicePipelineProtectedAccessFeaturesEXT& 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;
+}
+
+PhysicalDevicePipelineProtectedAccessFeaturesEXT::~PhysicalDevicePipelineProtectedAccessFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDevicePipelineProtectedAccessFeaturesEXT::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 PhysicalDevicePipelineProtectedAccessFeaturesEXT::initialize(const PhysicalDevicePipelineProtectedAccessFeaturesEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineProtectedAccess = copy_src->pipelineProtectedAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderObjectFeaturesEXT::PhysicalDeviceShaderObjectFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceShaderObjectFeaturesEXT::PhysicalDeviceShaderObjectFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT), pNext(nullptr), shaderObject() {}
+
+PhysicalDeviceShaderObjectFeaturesEXT::PhysicalDeviceShaderObjectFeaturesEXT(
+    const PhysicalDeviceShaderObjectFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderObject = copy_src.shaderObject;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderObjectFeaturesEXT& PhysicalDeviceShaderObjectFeaturesEXT::operator=(
+    const PhysicalDeviceShaderObjectFeaturesEXT& 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;
+}
+
+PhysicalDeviceShaderObjectFeaturesEXT::~PhysicalDeviceShaderObjectFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderObjectFeaturesEXT::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 PhysicalDeviceShaderObjectFeaturesEXT::initialize(const PhysicalDeviceShaderObjectFeaturesEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderObject = copy_src->shaderObject;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderObjectPropertiesEXT::PhysicalDeviceShaderObjectPropertiesEXT(
+    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];
+    }
+}
+
+PhysicalDeviceShaderObjectPropertiesEXT::PhysicalDeviceShaderObjectPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT), pNext(nullptr), shaderBinaryVersion() {}
+
+PhysicalDeviceShaderObjectPropertiesEXT::PhysicalDeviceShaderObjectPropertiesEXT(
+    const PhysicalDeviceShaderObjectPropertiesEXT& 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];
+    }
+}
+
+PhysicalDeviceShaderObjectPropertiesEXT& PhysicalDeviceShaderObjectPropertiesEXT::operator=(
+    const PhysicalDeviceShaderObjectPropertiesEXT& 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;
+}
+
+PhysicalDeviceShaderObjectPropertiesEXT::~PhysicalDeviceShaderObjectPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderObjectPropertiesEXT::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 PhysicalDeviceShaderObjectPropertiesEXT::initialize(const PhysicalDeviceShaderObjectPropertiesEXT* 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];
+    }
+}
+
+ShaderCreateInfoEXT::ShaderCreateInfoEXT(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 SpecializationInfo(in_struct->pSpecializationInfo);
+}
+
+ShaderCreateInfoEXT::ShaderCreateInfoEXT()
+    : 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) {}
+
+ShaderCreateInfoEXT::ShaderCreateInfoEXT(const ShaderCreateInfoEXT& 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 SpecializationInfo(*copy_src.pSpecializationInfo);
+}
+
+ShaderCreateInfoEXT& ShaderCreateInfoEXT::operator=(const ShaderCreateInfoEXT& 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 SpecializationInfo(*copy_src.pSpecializationInfo);
+
+    return *this;
+}
+
+ShaderCreateInfoEXT::~ShaderCreateInfoEXT() {
+    if (pName) delete[] pName;
+    if (pSetLayouts) delete[] pSetLayouts;
+    if (pPushConstantRanges) delete[] pPushConstantRanges;
+    if (pSpecializationInfo) delete pSpecializationInfo;
+    FreePnextChain(pNext);
+}
+
+void ShaderCreateInfoEXT::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 SpecializationInfo(in_struct->pSpecializationInfo);
+}
+
+void ShaderCreateInfoEXT::initialize(const ShaderCreateInfoEXT* 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 SpecializationInfo(*copy_src->pSpecializationInfo);
+}
+
+LayerSettingEXT::LayerSettingEXT(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);
+}
+
+LayerSettingEXT::LayerSettingEXT() : pLayerName(nullptr), pSettingName(nullptr), type(), valueCount(), pValues(nullptr) {}
+
+LayerSettingEXT::LayerSettingEXT(const LayerSettingEXT& copy_src) {
+    type = copy_src.type;
+    valueCount = copy_src.valueCount;
+    pValues = copy_src.pValues;
+    pLayerName = SafeStringCopy(copy_src.pLayerName);
+    pSettingName = SafeStringCopy(copy_src.pSettingName);
+}
+
+LayerSettingEXT& LayerSettingEXT::operator=(const LayerSettingEXT& 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;
+}
+
+LayerSettingEXT::~LayerSettingEXT() {
+    if (pLayerName) delete[] pLayerName;
+    if (pSettingName) delete[] pSettingName;
+}
+
+void LayerSettingEXT::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 LayerSettingEXT::initialize(const LayerSettingEXT* 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);
+}
+
+LayerSettingsCreateInfoEXT::LayerSettingsCreateInfoEXT(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 LayerSettingEXT[settingCount];
+        for (uint32_t i = 0; i < settingCount; ++i) {
+            pSettings[i].initialize(&in_struct->pSettings[i]);
+        }
+    }
+}
+
+LayerSettingsCreateInfoEXT::LayerSettingsCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT), pNext(nullptr), settingCount(), pSettings(nullptr) {}
+
+LayerSettingsCreateInfoEXT::LayerSettingsCreateInfoEXT(const LayerSettingsCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    settingCount = copy_src.settingCount;
+    pSettings = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (settingCount && copy_src.pSettings) {
+        pSettings = new LayerSettingEXT[settingCount];
+        for (uint32_t i = 0; i < settingCount; ++i) {
+            pSettings[i].initialize(&copy_src.pSettings[i]);
+        }
+    }
+}
+
+LayerSettingsCreateInfoEXT& LayerSettingsCreateInfoEXT::operator=(const LayerSettingsCreateInfoEXT& 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 LayerSettingEXT[settingCount];
+        for (uint32_t i = 0; i < settingCount; ++i) {
+            pSettings[i].initialize(&copy_src.pSettings[i]);
+        }
+    }
+
+    return *this;
+}
+
+LayerSettingsCreateInfoEXT::~LayerSettingsCreateInfoEXT() {
+    if (pSettings) delete[] pSettings;
+    FreePnextChain(pNext);
+}
+
+void LayerSettingsCreateInfoEXT::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 LayerSettingEXT[settingCount];
+        for (uint32_t i = 0; i < settingCount; ++i) {
+            pSettings[i].initialize(&in_struct->pSettings[i]);
+        }
+    }
+}
+
+void LayerSettingsCreateInfoEXT::initialize(const LayerSettingsCreateInfoEXT* 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 LayerSettingEXT[settingCount];
+        for (uint32_t i = 0; i < settingCount; ++i) {
+            pSettings[i].initialize(&copy_src->pSettings[i]);
+        }
+    }
+}
+
+PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT),
+      pNext(nullptr),
+      pipelineLibraryGroupHandles() {}
+
+PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    const PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    pipelineLibraryGroupHandles = copy_src.pipelineLibraryGroupHandles;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::operator=(
+    const PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& 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;
+}
+
+PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::~PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::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 PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::initialize(
+    const PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineLibraryGroupHandles = copy_src->pipelineLibraryGroupHandles;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT),
+      pNext(nullptr),
+      dynamicRenderingUnusedAttachments() {}
+
+PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+    const PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    dynamicRenderingUnusedAttachments = copy_src.dynamicRenderingUnusedAttachments;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::operator=(
+    const PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& 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;
+}
+
+PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::~PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::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 PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::initialize(
+    const PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dynamicRenderingUnusedAttachments = copy_src->dynamicRenderingUnusedAttachments;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    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);
+    }
+}
+
+PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT),
+      pNext(nullptr),
+      attachmentFeedbackLoopDynamicState() {}
+
+PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    const PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    attachmentFeedbackLoopDynamicState = copy_src.attachmentFeedbackLoopDynamicState;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::operator=(
+    const PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& 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;
+}
+
+PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::~PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::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 PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::initialize(
+    const PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    attachmentFeedbackLoopDynamicState = copy_src->attachmentFeedbackLoopDynamicState;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMeshShaderFeaturesEXT::PhysicalDeviceMeshShaderFeaturesEXT(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);
+    }
+}
+
+PhysicalDeviceMeshShaderFeaturesEXT::PhysicalDeviceMeshShaderFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT),
+      pNext(nullptr),
+      taskShader(),
+      meshShader(),
+      multiviewMeshShader(),
+      primitiveFragmentShadingRateMeshShader(),
+      meshShaderQueries() {}
+
+PhysicalDeviceMeshShaderFeaturesEXT::PhysicalDeviceMeshShaderFeaturesEXT(const PhysicalDeviceMeshShaderFeaturesEXT& 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);
+}
+
+PhysicalDeviceMeshShaderFeaturesEXT& PhysicalDeviceMeshShaderFeaturesEXT::operator=(
+    const PhysicalDeviceMeshShaderFeaturesEXT& 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;
+}
+
+PhysicalDeviceMeshShaderFeaturesEXT::~PhysicalDeviceMeshShaderFeaturesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMeshShaderFeaturesEXT::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 PhysicalDeviceMeshShaderFeaturesEXT::initialize(const PhysicalDeviceMeshShaderFeaturesEXT* 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);
+}
+
+PhysicalDeviceMeshShaderPropertiesEXT::PhysicalDeviceMeshShaderPropertiesEXT(
+    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];
+    }
+}
+
+PhysicalDeviceMeshShaderPropertiesEXT::PhysicalDeviceMeshShaderPropertiesEXT()
+    : 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() {}
+
+PhysicalDeviceMeshShaderPropertiesEXT::PhysicalDeviceMeshShaderPropertiesEXT(
+    const PhysicalDeviceMeshShaderPropertiesEXT& 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];
+    }
+}
+
+PhysicalDeviceMeshShaderPropertiesEXT& PhysicalDeviceMeshShaderPropertiesEXT::operator=(
+    const PhysicalDeviceMeshShaderPropertiesEXT& 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;
+}
+
+PhysicalDeviceMeshShaderPropertiesEXT::~PhysicalDeviceMeshShaderPropertiesEXT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMeshShaderPropertiesEXT::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 PhysicalDeviceMeshShaderPropertiesEXT::initialize(const PhysicalDeviceMeshShaderPropertiesEXT* 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 safe
+}  // 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..2c78970
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -0,0 +1,15369 @@
+// *** 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 {
+namespace safe {
+
+SwapchainCreateInfoKHR::SwapchainCreateInfoKHR(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;
+    }
+}
+
+SwapchainCreateInfoKHR::SwapchainCreateInfoKHR()
+    : 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() {}
+
+SwapchainCreateInfoKHR::SwapchainCreateInfoKHR(const SwapchainCreateInfoKHR& 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;
+    }
+}
+
+SwapchainCreateInfoKHR& SwapchainCreateInfoKHR::operator=(const SwapchainCreateInfoKHR& 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;
+}
+
+SwapchainCreateInfoKHR::~SwapchainCreateInfoKHR() {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+}
+
+void SwapchainCreateInfoKHR::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 SwapchainCreateInfoKHR::initialize(const SwapchainCreateInfoKHR* 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;
+    }
+}
+
+PresentInfoKHR::PresentInfoKHR(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);
+    }
+}
+
+PresentInfoKHR::PresentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PRESENT_INFO_KHR),
+      pNext(nullptr),
+      waitSemaphoreCount(),
+      pWaitSemaphores(nullptr),
+      swapchainCount(),
+      pSwapchains(nullptr),
+      pImageIndices(nullptr),
+      pResults(nullptr) {}
+
+PresentInfoKHR::PresentInfoKHR(const PresentInfoKHR& 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);
+    }
+}
+
+PresentInfoKHR& PresentInfoKHR::operator=(const PresentInfoKHR& 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;
+}
+
+PresentInfoKHR::~PresentInfoKHR() {
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pSwapchains) delete[] pSwapchains;
+    if (pImageIndices) delete[] pImageIndices;
+    if (pResults) delete[] pResults;
+    FreePnextChain(pNext);
+}
+
+void PresentInfoKHR::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 PresentInfoKHR::initialize(const PresentInfoKHR* 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);
+    }
+}
+
+ImageSwapchainCreateInfoKHR::ImageSwapchainCreateInfoKHR(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);
+    }
+}
+
+ImageSwapchainCreateInfoKHR::ImageSwapchainCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR), pNext(nullptr), swapchain() {}
+
+ImageSwapchainCreateInfoKHR::ImageSwapchainCreateInfoKHR(const ImageSwapchainCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    swapchain = copy_src.swapchain;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageSwapchainCreateInfoKHR& ImageSwapchainCreateInfoKHR::operator=(const ImageSwapchainCreateInfoKHR& 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;
+}
+
+ImageSwapchainCreateInfoKHR::~ImageSwapchainCreateInfoKHR() { FreePnextChain(pNext); }
+
+void ImageSwapchainCreateInfoKHR::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 ImageSwapchainCreateInfoKHR::initialize(const ImageSwapchainCreateInfoKHR* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchain = copy_src->swapchain;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BindImageMemorySwapchainInfoKHR::BindImageMemorySwapchainInfoKHR(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);
+    }
+}
+
+BindImageMemorySwapchainInfoKHR::BindImageMemorySwapchainInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR), pNext(nullptr), swapchain(), imageIndex() {}
+
+BindImageMemorySwapchainInfoKHR::BindImageMemorySwapchainInfoKHR(const BindImageMemorySwapchainInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    swapchain = copy_src.swapchain;
+    imageIndex = copy_src.imageIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BindImageMemorySwapchainInfoKHR& BindImageMemorySwapchainInfoKHR::operator=(const BindImageMemorySwapchainInfoKHR& 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;
+}
+
+BindImageMemorySwapchainInfoKHR::~BindImageMemorySwapchainInfoKHR() { FreePnextChain(pNext); }
+
+void BindImageMemorySwapchainInfoKHR::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 BindImageMemorySwapchainInfoKHR::initialize(const BindImageMemorySwapchainInfoKHR* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchain = copy_src->swapchain;
+    imageIndex = copy_src->imageIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+AcquireNextImageInfoKHR::AcquireNextImageInfoKHR(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);
+    }
+}
+
+AcquireNextImageInfoKHR::AcquireNextImageInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR),
+      pNext(nullptr),
+      swapchain(),
+      timeout(),
+      semaphore(),
+      fence(),
+      deviceMask() {}
+
+AcquireNextImageInfoKHR::AcquireNextImageInfoKHR(const AcquireNextImageInfoKHR& 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);
+}
+
+AcquireNextImageInfoKHR& AcquireNextImageInfoKHR::operator=(const AcquireNextImageInfoKHR& 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;
+}
+
+AcquireNextImageInfoKHR::~AcquireNextImageInfoKHR() { FreePnextChain(pNext); }
+
+void AcquireNextImageInfoKHR::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 AcquireNextImageInfoKHR::initialize(const AcquireNextImageInfoKHR* 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);
+}
+
+DeviceGroupPresentCapabilitiesKHR::DeviceGroupPresentCapabilitiesKHR(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];
+    }
+}
+
+DeviceGroupPresentCapabilitiesKHR::DeviceGroupPresentCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR), pNext(nullptr), modes() {}
+
+DeviceGroupPresentCapabilitiesKHR::DeviceGroupPresentCapabilitiesKHR(const DeviceGroupPresentCapabilitiesKHR& 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];
+    }
+}
+
+DeviceGroupPresentCapabilitiesKHR& DeviceGroupPresentCapabilitiesKHR::operator=(const DeviceGroupPresentCapabilitiesKHR& 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;
+}
+
+DeviceGroupPresentCapabilitiesKHR::~DeviceGroupPresentCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void DeviceGroupPresentCapabilitiesKHR::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 DeviceGroupPresentCapabilitiesKHR::initialize(const DeviceGroupPresentCapabilitiesKHR* 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];
+    }
+}
+
+DeviceGroupPresentInfoKHR::DeviceGroupPresentInfoKHR(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);
+    }
+}
+
+DeviceGroupPresentInfoKHR::DeviceGroupPresentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR), pNext(nullptr), swapchainCount(), pDeviceMasks(nullptr), mode() {}
+
+DeviceGroupPresentInfoKHR::DeviceGroupPresentInfoKHR(const DeviceGroupPresentInfoKHR& 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);
+    }
+}
+
+DeviceGroupPresentInfoKHR& DeviceGroupPresentInfoKHR::operator=(const DeviceGroupPresentInfoKHR& 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;
+}
+
+DeviceGroupPresentInfoKHR::~DeviceGroupPresentInfoKHR() {
+    if (pDeviceMasks) delete[] pDeviceMasks;
+    FreePnextChain(pNext);
+}
+
+void DeviceGroupPresentInfoKHR::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 DeviceGroupPresentInfoKHR::initialize(const DeviceGroupPresentInfoKHR* 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);
+    }
+}
+
+DeviceGroupSwapchainCreateInfoKHR::DeviceGroupSwapchainCreateInfoKHR(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);
+    }
+}
+
+DeviceGroupSwapchainCreateInfoKHR::DeviceGroupSwapchainCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR), pNext(nullptr), modes() {}
+
+DeviceGroupSwapchainCreateInfoKHR::DeviceGroupSwapchainCreateInfoKHR(const DeviceGroupSwapchainCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    modes = copy_src.modes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceGroupSwapchainCreateInfoKHR& DeviceGroupSwapchainCreateInfoKHR::operator=(const DeviceGroupSwapchainCreateInfoKHR& 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;
+}
+
+DeviceGroupSwapchainCreateInfoKHR::~DeviceGroupSwapchainCreateInfoKHR() { FreePnextChain(pNext); }
+
+void DeviceGroupSwapchainCreateInfoKHR::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 DeviceGroupSwapchainCreateInfoKHR::initialize(const DeviceGroupSwapchainCreateInfoKHR* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    modes = copy_src->modes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DisplayModeCreateInfoKHR::DisplayModeCreateInfoKHR(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);
+    }
+}
+
+DisplayModeCreateInfoKHR::DisplayModeCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR), pNext(nullptr), flags(), parameters() {}
+
+DisplayModeCreateInfoKHR::DisplayModeCreateInfoKHR(const DisplayModeCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    parameters = copy_src.parameters;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DisplayModeCreateInfoKHR& DisplayModeCreateInfoKHR::operator=(const DisplayModeCreateInfoKHR& 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;
+}
+
+DisplayModeCreateInfoKHR::~DisplayModeCreateInfoKHR() { FreePnextChain(pNext); }
+
+void DisplayModeCreateInfoKHR::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 DisplayModeCreateInfoKHR::initialize(const DisplayModeCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    parameters = copy_src->parameters;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DisplayPropertiesKHR::DisplayPropertiesKHR(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);
+}
+
+DisplayPropertiesKHR::DisplayPropertiesKHR()
+    : display(),
+      displayName(nullptr),
+      physicalDimensions(),
+      physicalResolution(),
+      supportedTransforms(),
+      planeReorderPossible(),
+      persistentContent() {}
+
+DisplayPropertiesKHR::DisplayPropertiesKHR(const DisplayPropertiesKHR& 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);
+}
+
+DisplayPropertiesKHR& DisplayPropertiesKHR::operator=(const DisplayPropertiesKHR& 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;
+}
+
+DisplayPropertiesKHR::~DisplayPropertiesKHR() {
+    if (displayName) delete[] displayName;
+}
+
+void DisplayPropertiesKHR::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 DisplayPropertiesKHR::initialize(const DisplayPropertiesKHR* 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);
+}
+
+DisplaySurfaceCreateInfoKHR::DisplaySurfaceCreateInfoKHR(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);
+    }
+}
+
+DisplaySurfaceCreateInfoKHR::DisplaySurfaceCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      displayMode(),
+      planeIndex(),
+      planeStackIndex(),
+      transform(),
+      globalAlpha(),
+      alphaMode(),
+      imageExtent() {}
+
+DisplaySurfaceCreateInfoKHR::DisplaySurfaceCreateInfoKHR(const DisplaySurfaceCreateInfoKHR& 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);
+}
+
+DisplaySurfaceCreateInfoKHR& DisplaySurfaceCreateInfoKHR::operator=(const DisplaySurfaceCreateInfoKHR& 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;
+}
+
+DisplaySurfaceCreateInfoKHR::~DisplaySurfaceCreateInfoKHR() { FreePnextChain(pNext); }
+
+void DisplaySurfaceCreateInfoKHR::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 DisplaySurfaceCreateInfoKHR::initialize(const DisplaySurfaceCreateInfoKHR* 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);
+}
+
+DisplayPresentInfoKHR::DisplayPresentInfoKHR(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);
+    }
+}
+
+DisplayPresentInfoKHR::DisplayPresentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR), pNext(nullptr), srcRect(), dstRect(), persistent() {}
+
+DisplayPresentInfoKHR::DisplayPresentInfoKHR(const DisplayPresentInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    srcRect = copy_src.srcRect;
+    dstRect = copy_src.dstRect;
+    persistent = copy_src.persistent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DisplayPresentInfoKHR& DisplayPresentInfoKHR::operator=(const DisplayPresentInfoKHR& 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;
+}
+
+DisplayPresentInfoKHR::~DisplayPresentInfoKHR() { FreePnextChain(pNext); }
+
+void DisplayPresentInfoKHR::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 DisplayPresentInfoKHR::initialize(const DisplayPresentInfoKHR* 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);
+}
+
+QueueFamilyQueryResultStatusPropertiesKHR::QueueFamilyQueryResultStatusPropertiesKHR(
+    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);
+    }
+}
+
+QueueFamilyQueryResultStatusPropertiesKHR::QueueFamilyQueryResultStatusPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR), pNext(nullptr), queryResultStatusSupport() {}
+
+QueueFamilyQueryResultStatusPropertiesKHR::QueueFamilyQueryResultStatusPropertiesKHR(
+    const QueueFamilyQueryResultStatusPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    queryResultStatusSupport = copy_src.queryResultStatusSupport;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+QueueFamilyQueryResultStatusPropertiesKHR& QueueFamilyQueryResultStatusPropertiesKHR::operator=(
+    const QueueFamilyQueryResultStatusPropertiesKHR& 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;
+}
+
+QueueFamilyQueryResultStatusPropertiesKHR::~QueueFamilyQueryResultStatusPropertiesKHR() { FreePnextChain(pNext); }
+
+void QueueFamilyQueryResultStatusPropertiesKHR::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 QueueFamilyQueryResultStatusPropertiesKHR::initialize(const QueueFamilyQueryResultStatusPropertiesKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queryResultStatusSupport = copy_src->queryResultStatusSupport;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+QueueFamilyVideoPropertiesKHR::QueueFamilyVideoPropertiesKHR(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);
+    }
+}
+
+QueueFamilyVideoPropertiesKHR::QueueFamilyVideoPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR), pNext(nullptr), videoCodecOperations() {}
+
+QueueFamilyVideoPropertiesKHR::QueueFamilyVideoPropertiesKHR(const QueueFamilyVideoPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    videoCodecOperations = copy_src.videoCodecOperations;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+QueueFamilyVideoPropertiesKHR& QueueFamilyVideoPropertiesKHR::operator=(const QueueFamilyVideoPropertiesKHR& 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;
+}
+
+QueueFamilyVideoPropertiesKHR::~QueueFamilyVideoPropertiesKHR() { FreePnextChain(pNext); }
+
+void QueueFamilyVideoPropertiesKHR::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 QueueFamilyVideoPropertiesKHR::initialize(const QueueFamilyVideoPropertiesKHR* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoCodecOperations = copy_src->videoCodecOperations;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoProfileInfoKHR::VideoProfileInfoKHR(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);
+    }
+}
+
+VideoProfileInfoKHR::VideoProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR),
+      pNext(nullptr),
+      videoCodecOperation(),
+      chromaSubsampling(),
+      lumaBitDepth(),
+      chromaBitDepth() {}
+
+VideoProfileInfoKHR::VideoProfileInfoKHR(const VideoProfileInfoKHR& 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);
+}
+
+VideoProfileInfoKHR& VideoProfileInfoKHR::operator=(const VideoProfileInfoKHR& 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;
+}
+
+VideoProfileInfoKHR::~VideoProfileInfoKHR() { FreePnextChain(pNext); }
+
+void VideoProfileInfoKHR::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 VideoProfileInfoKHR::initialize(const VideoProfileInfoKHR* 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);
+}
+
+VideoProfileListInfoKHR::VideoProfileListInfoKHR(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 VideoProfileInfoKHR[profileCount];
+        for (uint32_t i = 0; i < profileCount; ++i) {
+            pProfiles[i].initialize(&in_struct->pProfiles[i]);
+        }
+    }
+}
+
+VideoProfileListInfoKHR::VideoProfileListInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR), pNext(nullptr), profileCount(), pProfiles(nullptr) {}
+
+VideoProfileListInfoKHR::VideoProfileListInfoKHR(const VideoProfileListInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    profileCount = copy_src.profileCount;
+    pProfiles = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (profileCount && copy_src.pProfiles) {
+        pProfiles = new VideoProfileInfoKHR[profileCount];
+        for (uint32_t i = 0; i < profileCount; ++i) {
+            pProfiles[i].initialize(&copy_src.pProfiles[i]);
+        }
+    }
+}
+
+VideoProfileListInfoKHR& VideoProfileListInfoKHR::operator=(const VideoProfileListInfoKHR& 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 VideoProfileInfoKHR[profileCount];
+        for (uint32_t i = 0; i < profileCount; ++i) {
+            pProfiles[i].initialize(&copy_src.pProfiles[i]);
+        }
+    }
+
+    return *this;
+}
+
+VideoProfileListInfoKHR::~VideoProfileListInfoKHR() {
+    if (pProfiles) delete[] pProfiles;
+    FreePnextChain(pNext);
+}
+
+void VideoProfileListInfoKHR::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 VideoProfileInfoKHR[profileCount];
+        for (uint32_t i = 0; i < profileCount; ++i) {
+            pProfiles[i].initialize(&in_struct->pProfiles[i]);
+        }
+    }
+}
+
+void VideoProfileListInfoKHR::initialize(const VideoProfileListInfoKHR* 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 VideoProfileInfoKHR[profileCount];
+        for (uint32_t i = 0; i < profileCount; ++i) {
+            pProfiles[i].initialize(&copy_src->pProfiles[i]);
+        }
+    }
+}
+
+VideoCapabilitiesKHR::VideoCapabilitiesKHR(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);
+    }
+}
+
+VideoCapabilitiesKHR::VideoCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR),
+      pNext(nullptr),
+      flags(),
+      minBitstreamBufferOffsetAlignment(),
+      minBitstreamBufferSizeAlignment(),
+      pictureAccessGranularity(),
+      minCodedExtent(),
+      maxCodedExtent(),
+      maxDpbSlots(),
+      maxActiveReferencePictures(),
+      stdHeaderVersion() {}
+
+VideoCapabilitiesKHR::VideoCapabilitiesKHR(const VideoCapabilitiesKHR& 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);
+}
+
+VideoCapabilitiesKHR& VideoCapabilitiesKHR::operator=(const VideoCapabilitiesKHR& 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;
+}
+
+VideoCapabilitiesKHR::~VideoCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void VideoCapabilitiesKHR::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 VideoCapabilitiesKHR::initialize(const VideoCapabilitiesKHR* 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);
+}
+
+PhysicalDeviceVideoFormatInfoKHR::PhysicalDeviceVideoFormatInfoKHR(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);
+    }
+}
+
+PhysicalDeviceVideoFormatInfoKHR::PhysicalDeviceVideoFormatInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR), pNext(nullptr), imageUsage() {}
+
+PhysicalDeviceVideoFormatInfoKHR::PhysicalDeviceVideoFormatInfoKHR(const PhysicalDeviceVideoFormatInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    imageUsage = copy_src.imageUsage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceVideoFormatInfoKHR& PhysicalDeviceVideoFormatInfoKHR::operator=(const PhysicalDeviceVideoFormatInfoKHR& 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;
+}
+
+PhysicalDeviceVideoFormatInfoKHR::~PhysicalDeviceVideoFormatInfoKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVideoFormatInfoKHR::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 PhysicalDeviceVideoFormatInfoKHR::initialize(const PhysicalDeviceVideoFormatInfoKHR* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageUsage = copy_src->imageUsage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoFormatPropertiesKHR::VideoFormatPropertiesKHR(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);
+    }
+}
+
+VideoFormatPropertiesKHR::VideoFormatPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR),
+      pNext(nullptr),
+      format(),
+      componentMapping(),
+      imageCreateFlags(),
+      imageType(),
+      imageTiling(),
+      imageUsageFlags() {}
+
+VideoFormatPropertiesKHR::VideoFormatPropertiesKHR(const VideoFormatPropertiesKHR& 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);
+}
+
+VideoFormatPropertiesKHR& VideoFormatPropertiesKHR::operator=(const VideoFormatPropertiesKHR& 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;
+}
+
+VideoFormatPropertiesKHR::~VideoFormatPropertiesKHR() { FreePnextChain(pNext); }
+
+void VideoFormatPropertiesKHR::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 VideoFormatPropertiesKHR::initialize(const VideoFormatPropertiesKHR* 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);
+}
+
+VideoPictureResourceInfoKHR::VideoPictureResourceInfoKHR(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);
+    }
+}
+
+VideoPictureResourceInfoKHR::VideoPictureResourceInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR),
+      pNext(nullptr),
+      codedOffset(),
+      codedExtent(),
+      baseArrayLayer(),
+      imageViewBinding() {}
+
+VideoPictureResourceInfoKHR::VideoPictureResourceInfoKHR(const VideoPictureResourceInfoKHR& 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);
+}
+
+VideoPictureResourceInfoKHR& VideoPictureResourceInfoKHR::operator=(const VideoPictureResourceInfoKHR& 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;
+}
+
+VideoPictureResourceInfoKHR::~VideoPictureResourceInfoKHR() { FreePnextChain(pNext); }
+
+void VideoPictureResourceInfoKHR::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 VideoPictureResourceInfoKHR::initialize(const VideoPictureResourceInfoKHR* 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);
+}
+
+VideoReferenceSlotInfoKHR::VideoReferenceSlotInfoKHR(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 VideoPictureResourceInfoKHR(in_struct->pPictureResource);
+}
+
+VideoReferenceSlotInfoKHR::VideoReferenceSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR), pNext(nullptr), slotIndex(), pPictureResource(nullptr) {}
+
+VideoReferenceSlotInfoKHR::VideoReferenceSlotInfoKHR(const VideoReferenceSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    slotIndex = copy_src.slotIndex;
+    pPictureResource = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pPictureResource) pPictureResource = new VideoPictureResourceInfoKHR(*copy_src.pPictureResource);
+}
+
+VideoReferenceSlotInfoKHR& VideoReferenceSlotInfoKHR::operator=(const VideoReferenceSlotInfoKHR& 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 VideoPictureResourceInfoKHR(*copy_src.pPictureResource);
+
+    return *this;
+}
+
+VideoReferenceSlotInfoKHR::~VideoReferenceSlotInfoKHR() {
+    if (pPictureResource) delete pPictureResource;
+    FreePnextChain(pNext);
+}
+
+void VideoReferenceSlotInfoKHR::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 VideoPictureResourceInfoKHR(in_struct->pPictureResource);
+}
+
+void VideoReferenceSlotInfoKHR::initialize(const VideoReferenceSlotInfoKHR* 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 VideoPictureResourceInfoKHR(*copy_src->pPictureResource);
+}
+
+VideoSessionMemoryRequirementsKHR::VideoSessionMemoryRequirementsKHR(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);
+    }
+}
+
+VideoSessionMemoryRequirementsKHR::VideoSessionMemoryRequirementsKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR), pNext(nullptr), memoryBindIndex(), memoryRequirements() {}
+
+VideoSessionMemoryRequirementsKHR::VideoSessionMemoryRequirementsKHR(const VideoSessionMemoryRequirementsKHR& copy_src) {
+    sType = copy_src.sType;
+    memoryBindIndex = copy_src.memoryBindIndex;
+    memoryRequirements = copy_src.memoryRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoSessionMemoryRequirementsKHR& VideoSessionMemoryRequirementsKHR::operator=(const VideoSessionMemoryRequirementsKHR& 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;
+}
+
+VideoSessionMemoryRequirementsKHR::~VideoSessionMemoryRequirementsKHR() { FreePnextChain(pNext); }
+
+void VideoSessionMemoryRequirementsKHR::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 VideoSessionMemoryRequirementsKHR::initialize(const VideoSessionMemoryRequirementsKHR* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryBindIndex = copy_src->memoryBindIndex;
+    memoryRequirements = copy_src->memoryRequirements;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BindVideoSessionMemoryInfoKHR::BindVideoSessionMemoryInfoKHR(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);
+    }
+}
+
+BindVideoSessionMemoryInfoKHR::BindVideoSessionMemoryInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR),
+      pNext(nullptr),
+      memoryBindIndex(),
+      memory(),
+      memoryOffset(),
+      memorySize() {}
+
+BindVideoSessionMemoryInfoKHR::BindVideoSessionMemoryInfoKHR(const BindVideoSessionMemoryInfoKHR& 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);
+}
+
+BindVideoSessionMemoryInfoKHR& BindVideoSessionMemoryInfoKHR::operator=(const BindVideoSessionMemoryInfoKHR& 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;
+}
+
+BindVideoSessionMemoryInfoKHR::~BindVideoSessionMemoryInfoKHR() { FreePnextChain(pNext); }
+
+void BindVideoSessionMemoryInfoKHR::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 BindVideoSessionMemoryInfoKHR::initialize(const BindVideoSessionMemoryInfoKHR* 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);
+}
+
+VideoSessionCreateInfoKHR::VideoSessionCreateInfoKHR(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 VideoProfileInfoKHR(in_struct->pVideoProfile);
+
+    if (in_struct->pStdHeaderVersion) {
+        pStdHeaderVersion = new VkExtensionProperties(*in_struct->pStdHeaderVersion);
+    }
+}
+
+VideoSessionCreateInfoKHR::VideoSessionCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR),
+      pNext(nullptr),
+      queueFamilyIndex(),
+      flags(),
+      pVideoProfile(nullptr),
+      pictureFormat(),
+      maxCodedExtent(),
+      referencePictureFormat(),
+      maxDpbSlots(),
+      maxActiveReferencePictures(),
+      pStdHeaderVersion(nullptr) {}
+
+VideoSessionCreateInfoKHR::VideoSessionCreateInfoKHR(const VideoSessionCreateInfoKHR& 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 VideoProfileInfoKHR(*copy_src.pVideoProfile);
+
+    if (copy_src.pStdHeaderVersion) {
+        pStdHeaderVersion = new VkExtensionProperties(*copy_src.pStdHeaderVersion);
+    }
+}
+
+VideoSessionCreateInfoKHR& VideoSessionCreateInfoKHR::operator=(const VideoSessionCreateInfoKHR& 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 VideoProfileInfoKHR(*copy_src.pVideoProfile);
+
+    if (copy_src.pStdHeaderVersion) {
+        pStdHeaderVersion = new VkExtensionProperties(*copy_src.pStdHeaderVersion);
+    }
+
+    return *this;
+}
+
+VideoSessionCreateInfoKHR::~VideoSessionCreateInfoKHR() {
+    if (pVideoProfile) delete pVideoProfile;
+    if (pStdHeaderVersion) delete pStdHeaderVersion;
+    FreePnextChain(pNext);
+}
+
+void VideoSessionCreateInfoKHR::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 VideoProfileInfoKHR(in_struct->pVideoProfile);
+
+    if (in_struct->pStdHeaderVersion) {
+        pStdHeaderVersion = new VkExtensionProperties(*in_struct->pStdHeaderVersion);
+    }
+}
+
+void VideoSessionCreateInfoKHR::initialize(const VideoSessionCreateInfoKHR* 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 VideoProfileInfoKHR(*copy_src->pVideoProfile);
+
+    if (copy_src->pStdHeaderVersion) {
+        pStdHeaderVersion = new VkExtensionProperties(*copy_src->pStdHeaderVersion);
+    }
+}
+
+VideoSessionParametersCreateInfoKHR::VideoSessionParametersCreateInfoKHR(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);
+    }
+}
+
+VideoSessionParametersCreateInfoKHR::VideoSessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      videoSessionParametersTemplate(),
+      videoSession() {}
+
+VideoSessionParametersCreateInfoKHR::VideoSessionParametersCreateInfoKHR(const VideoSessionParametersCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    videoSessionParametersTemplate = copy_src.videoSessionParametersTemplate;
+    videoSession = copy_src.videoSession;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoSessionParametersCreateInfoKHR& VideoSessionParametersCreateInfoKHR::operator=(
+    const VideoSessionParametersCreateInfoKHR& 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;
+}
+
+VideoSessionParametersCreateInfoKHR::~VideoSessionParametersCreateInfoKHR() { FreePnextChain(pNext); }
+
+void VideoSessionParametersCreateInfoKHR::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 VideoSessionParametersCreateInfoKHR::initialize(const VideoSessionParametersCreateInfoKHR* 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);
+}
+
+VideoSessionParametersUpdateInfoKHR::VideoSessionParametersUpdateInfoKHR(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);
+    }
+}
+
+VideoSessionParametersUpdateInfoKHR::VideoSessionParametersUpdateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR), pNext(nullptr), updateSequenceCount() {}
+
+VideoSessionParametersUpdateInfoKHR::VideoSessionParametersUpdateInfoKHR(const VideoSessionParametersUpdateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    updateSequenceCount = copy_src.updateSequenceCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoSessionParametersUpdateInfoKHR& VideoSessionParametersUpdateInfoKHR::operator=(
+    const VideoSessionParametersUpdateInfoKHR& 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;
+}
+
+VideoSessionParametersUpdateInfoKHR::~VideoSessionParametersUpdateInfoKHR() { FreePnextChain(pNext); }
+
+void VideoSessionParametersUpdateInfoKHR::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 VideoSessionParametersUpdateInfoKHR::initialize(const VideoSessionParametersUpdateInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    updateSequenceCount = copy_src->updateSequenceCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoBeginCodingInfoKHR::VideoBeginCodingInfoKHR(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 VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+VideoBeginCodingInfoKHR::VideoBeginCodingInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      videoSession(),
+      videoSessionParameters(),
+      referenceSlotCount(),
+      pReferenceSlots(nullptr) {}
+
+VideoBeginCodingInfoKHR::VideoBeginCodingInfoKHR(const VideoBeginCodingInfoKHR& 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 VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+}
+
+VideoBeginCodingInfoKHR& VideoBeginCodingInfoKHR::operator=(const VideoBeginCodingInfoKHR& 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 VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+
+    return *this;
+}
+
+VideoBeginCodingInfoKHR::~VideoBeginCodingInfoKHR() {
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+}
+
+void VideoBeginCodingInfoKHR::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 VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+void VideoBeginCodingInfoKHR::initialize(const VideoBeginCodingInfoKHR* 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 VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src->pReferenceSlots[i]);
+        }
+    }
+}
+
+VideoEndCodingInfoKHR::VideoEndCodingInfoKHR(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);
+    }
+}
+
+VideoEndCodingInfoKHR::VideoEndCodingInfoKHR() : sType(VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR), pNext(nullptr), flags() {}
+
+VideoEndCodingInfoKHR::VideoEndCodingInfoKHR(const VideoEndCodingInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEndCodingInfoKHR& VideoEndCodingInfoKHR::operator=(const VideoEndCodingInfoKHR& 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;
+}
+
+VideoEndCodingInfoKHR::~VideoEndCodingInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEndCodingInfoKHR::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 VideoEndCodingInfoKHR::initialize(const VideoEndCodingInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoCodingControlInfoKHR::VideoCodingControlInfoKHR(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);
+    }
+}
+
+VideoCodingControlInfoKHR::VideoCodingControlInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR), pNext(nullptr), flags() {}
+
+VideoCodingControlInfoKHR::VideoCodingControlInfoKHR(const VideoCodingControlInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoCodingControlInfoKHR& VideoCodingControlInfoKHR::operator=(const VideoCodingControlInfoKHR& 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;
+}
+
+VideoCodingControlInfoKHR::~VideoCodingControlInfoKHR() { FreePnextChain(pNext); }
+
+void VideoCodingControlInfoKHR::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 VideoCodingControlInfoKHR::initialize(const VideoCodingControlInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoDecodeCapabilitiesKHR::VideoDecodeCapabilitiesKHR(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);
+    }
+}
+
+VideoDecodeCapabilitiesKHR::VideoDecodeCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR), pNext(nullptr), flags() {}
+
+VideoDecodeCapabilitiesKHR::VideoDecodeCapabilitiesKHR(const VideoDecodeCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoDecodeCapabilitiesKHR& VideoDecodeCapabilitiesKHR::operator=(const VideoDecodeCapabilitiesKHR& 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;
+}
+
+VideoDecodeCapabilitiesKHR::~VideoDecodeCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void VideoDecodeCapabilitiesKHR::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 VideoDecodeCapabilitiesKHR::initialize(const VideoDecodeCapabilitiesKHR* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoDecodeUsageInfoKHR::VideoDecodeUsageInfoKHR(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);
+    }
+}
+
+VideoDecodeUsageInfoKHR::VideoDecodeUsageInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR), pNext(nullptr), videoUsageHints() {}
+
+VideoDecodeUsageInfoKHR::VideoDecodeUsageInfoKHR(const VideoDecodeUsageInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    videoUsageHints = copy_src.videoUsageHints;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoDecodeUsageInfoKHR& VideoDecodeUsageInfoKHR::operator=(const VideoDecodeUsageInfoKHR& 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;
+}
+
+VideoDecodeUsageInfoKHR::~VideoDecodeUsageInfoKHR() { FreePnextChain(pNext); }
+
+void VideoDecodeUsageInfoKHR::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 VideoDecodeUsageInfoKHR::initialize(const VideoDecodeUsageInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoUsageHints = copy_src->videoUsageHints;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoDecodeInfoKHR::VideoDecodeInfoKHR(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 VideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot);
+    if (referenceSlotCount && in_struct->pReferenceSlots) {
+        pReferenceSlots = new VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+VideoDecodeInfoKHR::VideoDecodeInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      srcBuffer(),
+      srcBufferOffset(),
+      srcBufferRange(),
+      pSetupReferenceSlot(nullptr),
+      referenceSlotCount(),
+      pReferenceSlots(nullptr) {}
+
+VideoDecodeInfoKHR::VideoDecodeInfoKHR(const VideoDecodeInfoKHR& 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 VideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src.pReferenceSlots) {
+        pReferenceSlots = new VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+}
+
+VideoDecodeInfoKHR& VideoDecodeInfoKHR::operator=(const VideoDecodeInfoKHR& 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 VideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src.pReferenceSlots) {
+        pReferenceSlots = new VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+
+    return *this;
+}
+
+VideoDecodeInfoKHR::~VideoDecodeInfoKHR() {
+    if (pSetupReferenceSlot) delete pSetupReferenceSlot;
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeInfoKHR::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 VideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot);
+    if (referenceSlotCount && in_struct->pReferenceSlots) {
+        pReferenceSlots = new VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+void VideoDecodeInfoKHR::initialize(const VideoDecodeInfoKHR* 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 VideoReferenceSlotInfoKHR(*copy_src->pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src->pReferenceSlots) {
+        pReferenceSlots = new VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src->pReferenceSlots[i]);
+        }
+    }
+}
+
+VideoEncodeH264CapabilitiesKHR::VideoEncodeH264CapabilitiesKHR(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);
+    }
+}
+
+VideoEncodeH264CapabilitiesKHR::VideoEncodeH264CapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR),
+      pNext(nullptr),
+      flags(),
+      maxLevelIdc(),
+      maxSliceCount(),
+      maxPPictureL0ReferenceCount(),
+      maxBPictureL0ReferenceCount(),
+      maxL1ReferenceCount(),
+      maxTemporalLayerCount(),
+      expectDyadicTemporalLayerPattern(),
+      minQp(),
+      maxQp(),
+      prefersGopRemainingFrames(),
+      requiresGopRemainingFrames(),
+      stdSyntaxFlags() {}
+
+VideoEncodeH264CapabilitiesKHR::VideoEncodeH264CapabilitiesKHR(const VideoEncodeH264CapabilitiesKHR& 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);
+}
+
+VideoEncodeH264CapabilitiesKHR& VideoEncodeH264CapabilitiesKHR::operator=(const VideoEncodeH264CapabilitiesKHR& 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;
+}
+
+VideoEncodeH264CapabilitiesKHR::~VideoEncodeH264CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH264CapabilitiesKHR::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 VideoEncodeH264CapabilitiesKHR::initialize(const VideoEncodeH264CapabilitiesKHR* 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);
+}
+
+VideoEncodeH264QualityLevelPropertiesKHR::VideoEncodeH264QualityLevelPropertiesKHR(
+    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);
+    }
+}
+
+VideoEncodeH264QualityLevelPropertiesKHR::VideoEncodeH264QualityLevelPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR),
+      pNext(nullptr),
+      preferredRateControlFlags(),
+      preferredGopFrameCount(),
+      preferredIdrPeriod(),
+      preferredConsecutiveBFrameCount(),
+      preferredTemporalLayerCount(),
+      preferredConstantQp(),
+      preferredMaxL0ReferenceCount(),
+      preferredMaxL1ReferenceCount(),
+      preferredStdEntropyCodingModeFlag() {}
+
+VideoEncodeH264QualityLevelPropertiesKHR::VideoEncodeH264QualityLevelPropertiesKHR(
+    const VideoEncodeH264QualityLevelPropertiesKHR& 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);
+}
+
+VideoEncodeH264QualityLevelPropertiesKHR& VideoEncodeH264QualityLevelPropertiesKHR::operator=(
+    const VideoEncodeH264QualityLevelPropertiesKHR& 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;
+}
+
+VideoEncodeH264QualityLevelPropertiesKHR::~VideoEncodeH264QualityLevelPropertiesKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH264QualityLevelPropertiesKHR::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 VideoEncodeH264QualityLevelPropertiesKHR::initialize(const VideoEncodeH264QualityLevelPropertiesKHR* 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);
+}
+
+VideoEncodeH264SessionCreateInfoKHR::VideoEncodeH264SessionCreateInfoKHR(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);
+    }
+}
+
+VideoEncodeH264SessionCreateInfoKHR::VideoEncodeH264SessionCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR), pNext(nullptr), useMaxLevelIdc(), maxLevelIdc() {}
+
+VideoEncodeH264SessionCreateInfoKHR::VideoEncodeH264SessionCreateInfoKHR(const VideoEncodeH264SessionCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    useMaxLevelIdc = copy_src.useMaxLevelIdc;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEncodeH264SessionCreateInfoKHR& VideoEncodeH264SessionCreateInfoKHR::operator=(
+    const VideoEncodeH264SessionCreateInfoKHR& 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;
+}
+
+VideoEncodeH264SessionCreateInfoKHR::~VideoEncodeH264SessionCreateInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH264SessionCreateInfoKHR::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 VideoEncodeH264SessionCreateInfoKHR::initialize(const VideoEncodeH264SessionCreateInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    useMaxLevelIdc = copy_src->useMaxLevelIdc;
+    maxLevelIdc = copy_src->maxLevelIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoEncodeH264SessionParametersAddInfoKHR::VideoEncodeH264SessionParametersAddInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeH264SessionParametersAddInfoKHR::VideoEncodeH264SessionParametersAddInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR),
+      pNext(nullptr),
+      stdSPSCount(),
+      pStdSPSs(nullptr),
+      stdPPSCount(),
+      pStdPPSs(nullptr) {}
+
+VideoEncodeH264SessionParametersAddInfoKHR::VideoEncodeH264SessionParametersAddInfoKHR(
+    const VideoEncodeH264SessionParametersAddInfoKHR& 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);
+    }
+}
+
+VideoEncodeH264SessionParametersAddInfoKHR& VideoEncodeH264SessionParametersAddInfoKHR::operator=(
+    const VideoEncodeH264SessionParametersAddInfoKHR& 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;
+}
+
+VideoEncodeH264SessionParametersAddInfoKHR::~VideoEncodeH264SessionParametersAddInfoKHR() {
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeH264SessionParametersAddInfoKHR::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 VideoEncodeH264SessionParametersAddInfoKHR::initialize(const VideoEncodeH264SessionParametersAddInfoKHR* 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);
+    }
+}
+
+VideoEncodeH264SessionParametersCreateInfoKHR::VideoEncodeH264SessionParametersCreateInfoKHR(
+    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 VideoEncodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+VideoEncodeH264SessionParametersCreateInfoKHR::VideoEncodeH264SessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      maxStdSPSCount(),
+      maxStdPPSCount(),
+      pParametersAddInfo(nullptr) {}
+
+VideoEncodeH264SessionParametersCreateInfoKHR::VideoEncodeH264SessionParametersCreateInfoKHR(
+    const VideoEncodeH264SessionParametersCreateInfoKHR& 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 VideoEncodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+}
+
+VideoEncodeH264SessionParametersCreateInfoKHR& VideoEncodeH264SessionParametersCreateInfoKHR::operator=(
+    const VideoEncodeH264SessionParametersCreateInfoKHR& 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 VideoEncodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+
+    return *this;
+}
+
+VideoEncodeH264SessionParametersCreateInfoKHR::~VideoEncodeH264SessionParametersCreateInfoKHR() {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeH264SessionParametersCreateInfoKHR::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 VideoEncodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+void VideoEncodeH264SessionParametersCreateInfoKHR::initialize(const VideoEncodeH264SessionParametersCreateInfoKHR* 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 VideoEncodeH264SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo);
+}
+
+VideoEncodeH264SessionParametersGetInfoKHR::VideoEncodeH264SessionParametersGetInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeH264SessionParametersGetInfoKHR::VideoEncodeH264SessionParametersGetInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR),
+      pNext(nullptr),
+      writeStdSPS(),
+      writeStdPPS(),
+      stdSPSId(),
+      stdPPSId() {}
+
+VideoEncodeH264SessionParametersGetInfoKHR::VideoEncodeH264SessionParametersGetInfoKHR(
+    const VideoEncodeH264SessionParametersGetInfoKHR& 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);
+}
+
+VideoEncodeH264SessionParametersGetInfoKHR& VideoEncodeH264SessionParametersGetInfoKHR::operator=(
+    const VideoEncodeH264SessionParametersGetInfoKHR& 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;
+}
+
+VideoEncodeH264SessionParametersGetInfoKHR::~VideoEncodeH264SessionParametersGetInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH264SessionParametersGetInfoKHR::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 VideoEncodeH264SessionParametersGetInfoKHR::initialize(const VideoEncodeH264SessionParametersGetInfoKHR* 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);
+}
+
+VideoEncodeH264SessionParametersFeedbackInfoKHR::VideoEncodeH264SessionParametersFeedbackInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeH264SessionParametersFeedbackInfoKHR::VideoEncodeH264SessionParametersFeedbackInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR),
+      pNext(nullptr),
+      hasStdSPSOverrides(),
+      hasStdPPSOverrides() {}
+
+VideoEncodeH264SessionParametersFeedbackInfoKHR::VideoEncodeH264SessionParametersFeedbackInfoKHR(
+    const VideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    hasStdSPSOverrides = copy_src.hasStdSPSOverrides;
+    hasStdPPSOverrides = copy_src.hasStdPPSOverrides;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEncodeH264SessionParametersFeedbackInfoKHR& VideoEncodeH264SessionParametersFeedbackInfoKHR::operator=(
+    const VideoEncodeH264SessionParametersFeedbackInfoKHR& 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;
+}
+
+VideoEncodeH264SessionParametersFeedbackInfoKHR::~VideoEncodeH264SessionParametersFeedbackInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH264SessionParametersFeedbackInfoKHR::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 VideoEncodeH264SessionParametersFeedbackInfoKHR::initialize(const VideoEncodeH264SessionParametersFeedbackInfoKHR* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hasStdSPSOverrides = copy_src->hasStdSPSOverrides;
+    hasStdPPSOverrides = copy_src->hasStdPPSOverrides;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoEncodeH264NaluSliceInfoKHR::VideoEncodeH264NaluSliceInfoKHR(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);
+    }
+}
+
+VideoEncodeH264NaluSliceInfoKHR::VideoEncodeH264NaluSliceInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR), pNext(nullptr), constantQp(), pStdSliceHeader(nullptr) {}
+
+VideoEncodeH264NaluSliceInfoKHR::VideoEncodeH264NaluSliceInfoKHR(const VideoEncodeH264NaluSliceInfoKHR& 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);
+    }
+}
+
+VideoEncodeH264NaluSliceInfoKHR& VideoEncodeH264NaluSliceInfoKHR::operator=(const VideoEncodeH264NaluSliceInfoKHR& 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;
+}
+
+VideoEncodeH264NaluSliceInfoKHR::~VideoEncodeH264NaluSliceInfoKHR() {
+    if (pStdSliceHeader) delete pStdSliceHeader;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeH264NaluSliceInfoKHR::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 VideoEncodeH264NaluSliceInfoKHR::initialize(const VideoEncodeH264NaluSliceInfoKHR* 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);
+    }
+}
+
+VideoEncodeH264PictureInfoKHR::VideoEncodeH264PictureInfoKHR(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 VideoEncodeH264NaluSliceInfoKHR[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);
+    }
+}
+
+VideoEncodeH264PictureInfoKHR::VideoEncodeH264PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      naluSliceEntryCount(),
+      pNaluSliceEntries(nullptr),
+      pStdPictureInfo(nullptr),
+      generatePrefixNalu() {}
+
+VideoEncodeH264PictureInfoKHR::VideoEncodeH264PictureInfoKHR(const VideoEncodeH264PictureInfoKHR& 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 VideoEncodeH264NaluSliceInfoKHR[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);
+    }
+}
+
+VideoEncodeH264PictureInfoKHR& VideoEncodeH264PictureInfoKHR::operator=(const VideoEncodeH264PictureInfoKHR& 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 VideoEncodeH264NaluSliceInfoKHR[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;
+}
+
+VideoEncodeH264PictureInfoKHR::~VideoEncodeH264PictureInfoKHR() {
+    if (pNaluSliceEntries) delete[] pNaluSliceEntries;
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeH264PictureInfoKHR::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 VideoEncodeH264NaluSliceInfoKHR[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 VideoEncodeH264PictureInfoKHR::initialize(const VideoEncodeH264PictureInfoKHR* 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 VideoEncodeH264NaluSliceInfoKHR[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);
+    }
+}
+
+VideoEncodeH264DpbSlotInfoKHR::VideoEncodeH264DpbSlotInfoKHR(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);
+    }
+}
+
+VideoEncodeH264DpbSlotInfoKHR::VideoEncodeH264DpbSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {}
+
+VideoEncodeH264DpbSlotInfoKHR::VideoEncodeH264DpbSlotInfoKHR(const VideoEncodeH264DpbSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+}
+
+VideoEncodeH264DpbSlotInfoKHR& VideoEncodeH264DpbSlotInfoKHR::operator=(const VideoEncodeH264DpbSlotInfoKHR& 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;
+}
+
+VideoEncodeH264DpbSlotInfoKHR::~VideoEncodeH264DpbSlotInfoKHR() {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeH264DpbSlotInfoKHR::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 VideoEncodeH264DpbSlotInfoKHR::initialize(const VideoEncodeH264DpbSlotInfoKHR* 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);
+    }
+}
+
+VideoEncodeH264ProfileInfoKHR::VideoEncodeH264ProfileInfoKHR(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);
+    }
+}
+
+VideoEncodeH264ProfileInfoKHR::VideoEncodeH264ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {}
+
+VideoEncodeH264ProfileInfoKHR::VideoEncodeH264ProfileInfoKHR(const VideoEncodeH264ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEncodeH264ProfileInfoKHR& VideoEncodeH264ProfileInfoKHR::operator=(const VideoEncodeH264ProfileInfoKHR& 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;
+}
+
+VideoEncodeH264ProfileInfoKHR::~VideoEncodeH264ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH264ProfileInfoKHR::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 VideoEncodeH264ProfileInfoKHR::initialize(const VideoEncodeH264ProfileInfoKHR* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfileIdc = copy_src->stdProfileIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoEncodeH264RateControlInfoKHR::VideoEncodeH264RateControlInfoKHR(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);
+    }
+}
+
+VideoEncodeH264RateControlInfoKHR::VideoEncodeH264RateControlInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      gopFrameCount(),
+      idrPeriod(),
+      consecutiveBFrameCount(),
+      temporalLayerCount() {}
+
+VideoEncodeH264RateControlInfoKHR::VideoEncodeH264RateControlInfoKHR(const VideoEncodeH264RateControlInfoKHR& 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);
+}
+
+VideoEncodeH264RateControlInfoKHR& VideoEncodeH264RateControlInfoKHR::operator=(const VideoEncodeH264RateControlInfoKHR& 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;
+}
+
+VideoEncodeH264RateControlInfoKHR::~VideoEncodeH264RateControlInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH264RateControlInfoKHR::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 VideoEncodeH264RateControlInfoKHR::initialize(const VideoEncodeH264RateControlInfoKHR* 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);
+}
+
+VideoEncodeH264RateControlLayerInfoKHR::VideoEncodeH264RateControlLayerInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeH264RateControlLayerInfoKHR::VideoEncodeH264RateControlLayerInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR),
+      pNext(nullptr),
+      useMinQp(),
+      minQp(),
+      useMaxQp(),
+      maxQp(),
+      useMaxFrameSize(),
+      maxFrameSize() {}
+
+VideoEncodeH264RateControlLayerInfoKHR::VideoEncodeH264RateControlLayerInfoKHR(
+    const VideoEncodeH264RateControlLayerInfoKHR& 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);
+}
+
+VideoEncodeH264RateControlLayerInfoKHR& VideoEncodeH264RateControlLayerInfoKHR::operator=(
+    const VideoEncodeH264RateControlLayerInfoKHR& 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;
+}
+
+VideoEncodeH264RateControlLayerInfoKHR::~VideoEncodeH264RateControlLayerInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH264RateControlLayerInfoKHR::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 VideoEncodeH264RateControlLayerInfoKHR::initialize(const VideoEncodeH264RateControlLayerInfoKHR* 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);
+}
+
+VideoEncodeH264GopRemainingFrameInfoKHR::VideoEncodeH264GopRemainingFrameInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeH264GopRemainingFrameInfoKHR::VideoEncodeH264GopRemainingFrameInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR),
+      pNext(nullptr),
+      useGopRemainingFrames(),
+      gopRemainingI(),
+      gopRemainingP(),
+      gopRemainingB() {}
+
+VideoEncodeH264GopRemainingFrameInfoKHR::VideoEncodeH264GopRemainingFrameInfoKHR(
+    const VideoEncodeH264GopRemainingFrameInfoKHR& 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);
+}
+
+VideoEncodeH264GopRemainingFrameInfoKHR& VideoEncodeH264GopRemainingFrameInfoKHR::operator=(
+    const VideoEncodeH264GopRemainingFrameInfoKHR& 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;
+}
+
+VideoEncodeH264GopRemainingFrameInfoKHR::~VideoEncodeH264GopRemainingFrameInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH264GopRemainingFrameInfoKHR::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 VideoEncodeH264GopRemainingFrameInfoKHR::initialize(const VideoEncodeH264GopRemainingFrameInfoKHR* 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);
+}
+
+VideoEncodeH265CapabilitiesKHR::VideoEncodeH265CapabilitiesKHR(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);
+    }
+}
+
+VideoEncodeH265CapabilitiesKHR::VideoEncodeH265CapabilitiesKHR()
+    : 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() {}
+
+VideoEncodeH265CapabilitiesKHR::VideoEncodeH265CapabilitiesKHR(const VideoEncodeH265CapabilitiesKHR& 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);
+}
+
+VideoEncodeH265CapabilitiesKHR& VideoEncodeH265CapabilitiesKHR::operator=(const VideoEncodeH265CapabilitiesKHR& 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;
+}
+
+VideoEncodeH265CapabilitiesKHR::~VideoEncodeH265CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH265CapabilitiesKHR::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 VideoEncodeH265CapabilitiesKHR::initialize(const VideoEncodeH265CapabilitiesKHR* 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);
+}
+
+VideoEncodeH265SessionCreateInfoKHR::VideoEncodeH265SessionCreateInfoKHR(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);
+    }
+}
+
+VideoEncodeH265SessionCreateInfoKHR::VideoEncodeH265SessionCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR), pNext(nullptr), useMaxLevelIdc(), maxLevelIdc() {}
+
+VideoEncodeH265SessionCreateInfoKHR::VideoEncodeH265SessionCreateInfoKHR(const VideoEncodeH265SessionCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    useMaxLevelIdc = copy_src.useMaxLevelIdc;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEncodeH265SessionCreateInfoKHR& VideoEncodeH265SessionCreateInfoKHR::operator=(
+    const VideoEncodeH265SessionCreateInfoKHR& 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;
+}
+
+VideoEncodeH265SessionCreateInfoKHR::~VideoEncodeH265SessionCreateInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH265SessionCreateInfoKHR::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 VideoEncodeH265SessionCreateInfoKHR::initialize(const VideoEncodeH265SessionCreateInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    useMaxLevelIdc = copy_src->useMaxLevelIdc;
+    maxLevelIdc = copy_src->maxLevelIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoEncodeH265QualityLevelPropertiesKHR::VideoEncodeH265QualityLevelPropertiesKHR(
+    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);
+    }
+}
+
+VideoEncodeH265QualityLevelPropertiesKHR::VideoEncodeH265QualityLevelPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR),
+      pNext(nullptr),
+      preferredRateControlFlags(),
+      preferredGopFrameCount(),
+      preferredIdrPeriod(),
+      preferredConsecutiveBFrameCount(),
+      preferredSubLayerCount(),
+      preferredConstantQp(),
+      preferredMaxL0ReferenceCount(),
+      preferredMaxL1ReferenceCount() {}
+
+VideoEncodeH265QualityLevelPropertiesKHR::VideoEncodeH265QualityLevelPropertiesKHR(
+    const VideoEncodeH265QualityLevelPropertiesKHR& 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);
+}
+
+VideoEncodeH265QualityLevelPropertiesKHR& VideoEncodeH265QualityLevelPropertiesKHR::operator=(
+    const VideoEncodeH265QualityLevelPropertiesKHR& 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;
+}
+
+VideoEncodeH265QualityLevelPropertiesKHR::~VideoEncodeH265QualityLevelPropertiesKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH265QualityLevelPropertiesKHR::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 VideoEncodeH265QualityLevelPropertiesKHR::initialize(const VideoEncodeH265QualityLevelPropertiesKHR* 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);
+}
+
+VideoEncodeH265SessionParametersAddInfoKHR::VideoEncodeH265SessionParametersAddInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeH265SessionParametersAddInfoKHR::VideoEncodeH265SessionParametersAddInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR),
+      pNext(nullptr),
+      stdVPSCount(),
+      pStdVPSs(nullptr),
+      stdSPSCount(),
+      pStdSPSs(nullptr),
+      stdPPSCount(),
+      pStdPPSs(nullptr) {}
+
+VideoEncodeH265SessionParametersAddInfoKHR::VideoEncodeH265SessionParametersAddInfoKHR(
+    const VideoEncodeH265SessionParametersAddInfoKHR& 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);
+    }
+}
+
+VideoEncodeH265SessionParametersAddInfoKHR& VideoEncodeH265SessionParametersAddInfoKHR::operator=(
+    const VideoEncodeH265SessionParametersAddInfoKHR& 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;
+}
+
+VideoEncodeH265SessionParametersAddInfoKHR::~VideoEncodeH265SessionParametersAddInfoKHR() {
+    if (pStdVPSs) delete[] pStdVPSs;
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeH265SessionParametersAddInfoKHR::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 VideoEncodeH265SessionParametersAddInfoKHR::initialize(const VideoEncodeH265SessionParametersAddInfoKHR* 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);
+    }
+}
+
+VideoEncodeH265SessionParametersCreateInfoKHR::VideoEncodeH265SessionParametersCreateInfoKHR(
+    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 VideoEncodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+VideoEncodeH265SessionParametersCreateInfoKHR::VideoEncodeH265SessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      maxStdVPSCount(),
+      maxStdSPSCount(),
+      maxStdPPSCount(),
+      pParametersAddInfo(nullptr) {}
+
+VideoEncodeH265SessionParametersCreateInfoKHR::VideoEncodeH265SessionParametersCreateInfoKHR(
+    const VideoEncodeH265SessionParametersCreateInfoKHR& 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 VideoEncodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+}
+
+VideoEncodeH265SessionParametersCreateInfoKHR& VideoEncodeH265SessionParametersCreateInfoKHR::operator=(
+    const VideoEncodeH265SessionParametersCreateInfoKHR& 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 VideoEncodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+
+    return *this;
+}
+
+VideoEncodeH265SessionParametersCreateInfoKHR::~VideoEncodeH265SessionParametersCreateInfoKHR() {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeH265SessionParametersCreateInfoKHR::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 VideoEncodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+void VideoEncodeH265SessionParametersCreateInfoKHR::initialize(const VideoEncodeH265SessionParametersCreateInfoKHR* 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 VideoEncodeH265SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo);
+}
+
+VideoEncodeH265SessionParametersGetInfoKHR::VideoEncodeH265SessionParametersGetInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeH265SessionParametersGetInfoKHR::VideoEncodeH265SessionParametersGetInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR),
+      pNext(nullptr),
+      writeStdVPS(),
+      writeStdSPS(),
+      writeStdPPS(),
+      stdVPSId(),
+      stdSPSId(),
+      stdPPSId() {}
+
+VideoEncodeH265SessionParametersGetInfoKHR::VideoEncodeH265SessionParametersGetInfoKHR(
+    const VideoEncodeH265SessionParametersGetInfoKHR& 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);
+}
+
+VideoEncodeH265SessionParametersGetInfoKHR& VideoEncodeH265SessionParametersGetInfoKHR::operator=(
+    const VideoEncodeH265SessionParametersGetInfoKHR& 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;
+}
+
+VideoEncodeH265SessionParametersGetInfoKHR::~VideoEncodeH265SessionParametersGetInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH265SessionParametersGetInfoKHR::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 VideoEncodeH265SessionParametersGetInfoKHR::initialize(const VideoEncodeH265SessionParametersGetInfoKHR* 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);
+}
+
+VideoEncodeH265SessionParametersFeedbackInfoKHR::VideoEncodeH265SessionParametersFeedbackInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeH265SessionParametersFeedbackInfoKHR::VideoEncodeH265SessionParametersFeedbackInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR),
+      pNext(nullptr),
+      hasStdVPSOverrides(),
+      hasStdSPSOverrides(),
+      hasStdPPSOverrides() {}
+
+VideoEncodeH265SessionParametersFeedbackInfoKHR::VideoEncodeH265SessionParametersFeedbackInfoKHR(
+    const VideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    hasStdVPSOverrides = copy_src.hasStdVPSOverrides;
+    hasStdSPSOverrides = copy_src.hasStdSPSOverrides;
+    hasStdPPSOverrides = copy_src.hasStdPPSOverrides;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEncodeH265SessionParametersFeedbackInfoKHR& VideoEncodeH265SessionParametersFeedbackInfoKHR::operator=(
+    const VideoEncodeH265SessionParametersFeedbackInfoKHR& 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;
+}
+
+VideoEncodeH265SessionParametersFeedbackInfoKHR::~VideoEncodeH265SessionParametersFeedbackInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH265SessionParametersFeedbackInfoKHR::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 VideoEncodeH265SessionParametersFeedbackInfoKHR::initialize(const VideoEncodeH265SessionParametersFeedbackInfoKHR* 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);
+}
+
+VideoEncodeH265NaluSliceSegmentInfoKHR::VideoEncodeH265NaluSliceSegmentInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeH265NaluSliceSegmentInfoKHR::VideoEncodeH265NaluSliceSegmentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR),
+      pNext(nullptr),
+      constantQp(),
+      pStdSliceSegmentHeader(nullptr) {}
+
+VideoEncodeH265NaluSliceSegmentInfoKHR::VideoEncodeH265NaluSliceSegmentInfoKHR(
+    const VideoEncodeH265NaluSliceSegmentInfoKHR& 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);
+    }
+}
+
+VideoEncodeH265NaluSliceSegmentInfoKHR& VideoEncodeH265NaluSliceSegmentInfoKHR::operator=(
+    const VideoEncodeH265NaluSliceSegmentInfoKHR& 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;
+}
+
+VideoEncodeH265NaluSliceSegmentInfoKHR::~VideoEncodeH265NaluSliceSegmentInfoKHR() {
+    if (pStdSliceSegmentHeader) delete pStdSliceSegmentHeader;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeH265NaluSliceSegmentInfoKHR::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 VideoEncodeH265NaluSliceSegmentInfoKHR::initialize(const VideoEncodeH265NaluSliceSegmentInfoKHR* 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);
+    }
+}
+
+VideoEncodeH265PictureInfoKHR::VideoEncodeH265PictureInfoKHR(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 VideoEncodeH265NaluSliceSegmentInfoKHR[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);
+    }
+}
+
+VideoEncodeH265PictureInfoKHR::VideoEncodeH265PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      naluSliceSegmentEntryCount(),
+      pNaluSliceSegmentEntries(nullptr),
+      pStdPictureInfo(nullptr) {}
+
+VideoEncodeH265PictureInfoKHR::VideoEncodeH265PictureInfoKHR(const VideoEncodeH265PictureInfoKHR& 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 VideoEncodeH265NaluSliceSegmentInfoKHR[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);
+    }
+}
+
+VideoEncodeH265PictureInfoKHR& VideoEncodeH265PictureInfoKHR::operator=(const VideoEncodeH265PictureInfoKHR& 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 VideoEncodeH265NaluSliceSegmentInfoKHR[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;
+}
+
+VideoEncodeH265PictureInfoKHR::~VideoEncodeH265PictureInfoKHR() {
+    if (pNaluSliceSegmentEntries) delete[] pNaluSliceSegmentEntries;
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeH265PictureInfoKHR::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 VideoEncodeH265NaluSliceSegmentInfoKHR[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 VideoEncodeH265PictureInfoKHR::initialize(const VideoEncodeH265PictureInfoKHR* 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 VideoEncodeH265NaluSliceSegmentInfoKHR[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);
+    }
+}
+
+VideoEncodeH265DpbSlotInfoKHR::VideoEncodeH265DpbSlotInfoKHR(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);
+    }
+}
+
+VideoEncodeH265DpbSlotInfoKHR::VideoEncodeH265DpbSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {}
+
+VideoEncodeH265DpbSlotInfoKHR::VideoEncodeH265DpbSlotInfoKHR(const VideoEncodeH265DpbSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+}
+
+VideoEncodeH265DpbSlotInfoKHR& VideoEncodeH265DpbSlotInfoKHR::operator=(const VideoEncodeH265DpbSlotInfoKHR& 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;
+}
+
+VideoEncodeH265DpbSlotInfoKHR::~VideoEncodeH265DpbSlotInfoKHR() {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeH265DpbSlotInfoKHR::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 VideoEncodeH265DpbSlotInfoKHR::initialize(const VideoEncodeH265DpbSlotInfoKHR* 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);
+    }
+}
+
+VideoEncodeH265ProfileInfoKHR::VideoEncodeH265ProfileInfoKHR(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);
+    }
+}
+
+VideoEncodeH265ProfileInfoKHR::VideoEncodeH265ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {}
+
+VideoEncodeH265ProfileInfoKHR::VideoEncodeH265ProfileInfoKHR(const VideoEncodeH265ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEncodeH265ProfileInfoKHR& VideoEncodeH265ProfileInfoKHR::operator=(const VideoEncodeH265ProfileInfoKHR& 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;
+}
+
+VideoEncodeH265ProfileInfoKHR::~VideoEncodeH265ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH265ProfileInfoKHR::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 VideoEncodeH265ProfileInfoKHR::initialize(const VideoEncodeH265ProfileInfoKHR* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfileIdc = copy_src->stdProfileIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoEncodeH265RateControlInfoKHR::VideoEncodeH265RateControlInfoKHR(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);
+    }
+}
+
+VideoEncodeH265RateControlInfoKHR::VideoEncodeH265RateControlInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      gopFrameCount(),
+      idrPeriod(),
+      consecutiveBFrameCount(),
+      subLayerCount() {}
+
+VideoEncodeH265RateControlInfoKHR::VideoEncodeH265RateControlInfoKHR(const VideoEncodeH265RateControlInfoKHR& 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);
+}
+
+VideoEncodeH265RateControlInfoKHR& VideoEncodeH265RateControlInfoKHR::operator=(const VideoEncodeH265RateControlInfoKHR& 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;
+}
+
+VideoEncodeH265RateControlInfoKHR::~VideoEncodeH265RateControlInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH265RateControlInfoKHR::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 VideoEncodeH265RateControlInfoKHR::initialize(const VideoEncodeH265RateControlInfoKHR* 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);
+}
+
+VideoEncodeH265RateControlLayerInfoKHR::VideoEncodeH265RateControlLayerInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeH265RateControlLayerInfoKHR::VideoEncodeH265RateControlLayerInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR),
+      pNext(nullptr),
+      useMinQp(),
+      minQp(),
+      useMaxQp(),
+      maxQp(),
+      useMaxFrameSize(),
+      maxFrameSize() {}
+
+VideoEncodeH265RateControlLayerInfoKHR::VideoEncodeH265RateControlLayerInfoKHR(
+    const VideoEncodeH265RateControlLayerInfoKHR& 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);
+}
+
+VideoEncodeH265RateControlLayerInfoKHR& VideoEncodeH265RateControlLayerInfoKHR::operator=(
+    const VideoEncodeH265RateControlLayerInfoKHR& 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;
+}
+
+VideoEncodeH265RateControlLayerInfoKHR::~VideoEncodeH265RateControlLayerInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH265RateControlLayerInfoKHR::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 VideoEncodeH265RateControlLayerInfoKHR::initialize(const VideoEncodeH265RateControlLayerInfoKHR* 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);
+}
+
+VideoEncodeH265GopRemainingFrameInfoKHR::VideoEncodeH265GopRemainingFrameInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeH265GopRemainingFrameInfoKHR::VideoEncodeH265GopRemainingFrameInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR),
+      pNext(nullptr),
+      useGopRemainingFrames(),
+      gopRemainingI(),
+      gopRemainingP(),
+      gopRemainingB() {}
+
+VideoEncodeH265GopRemainingFrameInfoKHR::VideoEncodeH265GopRemainingFrameInfoKHR(
+    const VideoEncodeH265GopRemainingFrameInfoKHR& 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);
+}
+
+VideoEncodeH265GopRemainingFrameInfoKHR& VideoEncodeH265GopRemainingFrameInfoKHR::operator=(
+    const VideoEncodeH265GopRemainingFrameInfoKHR& 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;
+}
+
+VideoEncodeH265GopRemainingFrameInfoKHR::~VideoEncodeH265GopRemainingFrameInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeH265GopRemainingFrameInfoKHR::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 VideoEncodeH265GopRemainingFrameInfoKHR::initialize(const VideoEncodeH265GopRemainingFrameInfoKHR* 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);
+}
+
+VideoDecodeH264ProfileInfoKHR::VideoDecodeH264ProfileInfoKHR(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);
+    }
+}
+
+VideoDecodeH264ProfileInfoKHR::VideoDecodeH264ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc(), pictureLayout() {}
+
+VideoDecodeH264ProfileInfoKHR::VideoDecodeH264ProfileInfoKHR(const VideoDecodeH264ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pictureLayout = copy_src.pictureLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoDecodeH264ProfileInfoKHR& VideoDecodeH264ProfileInfoKHR::operator=(const VideoDecodeH264ProfileInfoKHR& 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;
+}
+
+VideoDecodeH264ProfileInfoKHR::~VideoDecodeH264ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void VideoDecodeH264ProfileInfoKHR::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 VideoDecodeH264ProfileInfoKHR::initialize(const VideoDecodeH264ProfileInfoKHR* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfileIdc = copy_src->stdProfileIdc;
+    pictureLayout = copy_src->pictureLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoDecodeH264CapabilitiesKHR::VideoDecodeH264CapabilitiesKHR(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);
+    }
+}
+
+VideoDecodeH264CapabilitiesKHR::VideoDecodeH264CapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR), pNext(nullptr), maxLevelIdc(), fieldOffsetGranularity() {}
+
+VideoDecodeH264CapabilitiesKHR::VideoDecodeH264CapabilitiesKHR(const VideoDecodeH264CapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    fieldOffsetGranularity = copy_src.fieldOffsetGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoDecodeH264CapabilitiesKHR& VideoDecodeH264CapabilitiesKHR::operator=(const VideoDecodeH264CapabilitiesKHR& 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;
+}
+
+VideoDecodeH264CapabilitiesKHR::~VideoDecodeH264CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void VideoDecodeH264CapabilitiesKHR::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 VideoDecodeH264CapabilitiesKHR::initialize(const VideoDecodeH264CapabilitiesKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxLevelIdc = copy_src->maxLevelIdc;
+    fieldOffsetGranularity = copy_src->fieldOffsetGranularity;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoDecodeH264SessionParametersAddInfoKHR::VideoDecodeH264SessionParametersAddInfoKHR(
+    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);
+    }
+}
+
+VideoDecodeH264SessionParametersAddInfoKHR::VideoDecodeH264SessionParametersAddInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR),
+      pNext(nullptr),
+      stdSPSCount(),
+      pStdSPSs(nullptr),
+      stdPPSCount(),
+      pStdPPSs(nullptr) {}
+
+VideoDecodeH264SessionParametersAddInfoKHR::VideoDecodeH264SessionParametersAddInfoKHR(
+    const VideoDecodeH264SessionParametersAddInfoKHR& 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);
+    }
+}
+
+VideoDecodeH264SessionParametersAddInfoKHR& VideoDecodeH264SessionParametersAddInfoKHR::operator=(
+    const VideoDecodeH264SessionParametersAddInfoKHR& 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;
+}
+
+VideoDecodeH264SessionParametersAddInfoKHR::~VideoDecodeH264SessionParametersAddInfoKHR() {
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeH264SessionParametersAddInfoKHR::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 VideoDecodeH264SessionParametersAddInfoKHR::initialize(const VideoDecodeH264SessionParametersAddInfoKHR* 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);
+    }
+}
+
+VideoDecodeH264SessionParametersCreateInfoKHR::VideoDecodeH264SessionParametersCreateInfoKHR(
+    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 VideoDecodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+VideoDecodeH264SessionParametersCreateInfoKHR::VideoDecodeH264SessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      maxStdSPSCount(),
+      maxStdPPSCount(),
+      pParametersAddInfo(nullptr) {}
+
+VideoDecodeH264SessionParametersCreateInfoKHR::VideoDecodeH264SessionParametersCreateInfoKHR(
+    const VideoDecodeH264SessionParametersCreateInfoKHR& 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 VideoDecodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+}
+
+VideoDecodeH264SessionParametersCreateInfoKHR& VideoDecodeH264SessionParametersCreateInfoKHR::operator=(
+    const VideoDecodeH264SessionParametersCreateInfoKHR& 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 VideoDecodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+
+    return *this;
+}
+
+VideoDecodeH264SessionParametersCreateInfoKHR::~VideoDecodeH264SessionParametersCreateInfoKHR() {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeH264SessionParametersCreateInfoKHR::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 VideoDecodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+void VideoDecodeH264SessionParametersCreateInfoKHR::initialize(const VideoDecodeH264SessionParametersCreateInfoKHR* 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 VideoDecodeH264SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo);
+}
+
+VideoDecodeH264PictureInfoKHR::VideoDecodeH264PictureInfoKHR(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);
+    }
+}
+
+VideoDecodeH264PictureInfoKHR::VideoDecodeH264PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      pStdPictureInfo(nullptr),
+      sliceCount(),
+      pSliceOffsets(nullptr) {}
+
+VideoDecodeH264PictureInfoKHR::VideoDecodeH264PictureInfoKHR(const VideoDecodeH264PictureInfoKHR& 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);
+    }
+}
+
+VideoDecodeH264PictureInfoKHR& VideoDecodeH264PictureInfoKHR::operator=(const VideoDecodeH264PictureInfoKHR& 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;
+}
+
+VideoDecodeH264PictureInfoKHR::~VideoDecodeH264PictureInfoKHR() {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pSliceOffsets) delete[] pSliceOffsets;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeH264PictureInfoKHR::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 VideoDecodeH264PictureInfoKHR::initialize(const VideoDecodeH264PictureInfoKHR* 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);
+    }
+}
+
+VideoDecodeH264DpbSlotInfoKHR::VideoDecodeH264DpbSlotInfoKHR(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);
+    }
+}
+
+VideoDecodeH264DpbSlotInfoKHR::VideoDecodeH264DpbSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {}
+
+VideoDecodeH264DpbSlotInfoKHR::VideoDecodeH264DpbSlotInfoKHR(const VideoDecodeH264DpbSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+}
+
+VideoDecodeH264DpbSlotInfoKHR& VideoDecodeH264DpbSlotInfoKHR::operator=(const VideoDecodeH264DpbSlotInfoKHR& 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;
+}
+
+VideoDecodeH264DpbSlotInfoKHR::~VideoDecodeH264DpbSlotInfoKHR() {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeH264DpbSlotInfoKHR::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 VideoDecodeH264DpbSlotInfoKHR::initialize(const VideoDecodeH264DpbSlotInfoKHR* 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);
+    }
+}
+
+RenderingFragmentShadingRateAttachmentInfoKHR::RenderingFragmentShadingRateAttachmentInfoKHR(
+    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);
+    }
+}
+
+RenderingFragmentShadingRateAttachmentInfoKHR::RenderingFragmentShadingRateAttachmentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR),
+      pNext(nullptr),
+      imageView(),
+      imageLayout(),
+      shadingRateAttachmentTexelSize() {}
+
+RenderingFragmentShadingRateAttachmentInfoKHR::RenderingFragmentShadingRateAttachmentInfoKHR(
+    const RenderingFragmentShadingRateAttachmentInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+RenderingFragmentShadingRateAttachmentInfoKHR& RenderingFragmentShadingRateAttachmentInfoKHR::operator=(
+    const RenderingFragmentShadingRateAttachmentInfoKHR& 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;
+}
+
+RenderingFragmentShadingRateAttachmentInfoKHR::~RenderingFragmentShadingRateAttachmentInfoKHR() { FreePnextChain(pNext); }
+
+void RenderingFragmentShadingRateAttachmentInfoKHR::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 RenderingFragmentShadingRateAttachmentInfoKHR::initialize(const RenderingFragmentShadingRateAttachmentInfoKHR* 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
+
+ImportMemoryWin32HandleInfoKHR::ImportMemoryWin32HandleInfoKHR(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);
+    }
+}
+
+ImportMemoryWin32HandleInfoKHR::ImportMemoryWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR), pNext(nullptr), handleType(), handle(), name() {}
+
+ImportMemoryWin32HandleInfoKHR::ImportMemoryWin32HandleInfoKHR(const ImportMemoryWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImportMemoryWin32HandleInfoKHR& ImportMemoryWin32HandleInfoKHR::operator=(const ImportMemoryWin32HandleInfoKHR& 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;
+}
+
+ImportMemoryWin32HandleInfoKHR::~ImportMemoryWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void ImportMemoryWin32HandleInfoKHR::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 ImportMemoryWin32HandleInfoKHR::initialize(const ImportMemoryWin32HandleInfoKHR* 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);
+}
+
+ExportMemoryWin32HandleInfoKHR::ExportMemoryWin32HandleInfoKHR(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);
+    }
+}
+
+ExportMemoryWin32HandleInfoKHR::ExportMemoryWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {}
+
+ExportMemoryWin32HandleInfoKHR::ExportMemoryWin32HandleInfoKHR(const ExportMemoryWin32HandleInfoKHR& 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);
+    }
+}
+
+ExportMemoryWin32HandleInfoKHR& ExportMemoryWin32HandleInfoKHR::operator=(const ExportMemoryWin32HandleInfoKHR& 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;
+}
+
+ExportMemoryWin32HandleInfoKHR::~ExportMemoryWin32HandleInfoKHR() {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+}
+
+void ExportMemoryWin32HandleInfoKHR::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 ExportMemoryWin32HandleInfoKHR::initialize(const ExportMemoryWin32HandleInfoKHR* 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);
+    }
+}
+
+MemoryWin32HandlePropertiesKHR::MemoryWin32HandlePropertiesKHR(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);
+    }
+}
+
+MemoryWin32HandlePropertiesKHR::MemoryWin32HandlePropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR), pNext(nullptr), memoryTypeBits() {}
+
+MemoryWin32HandlePropertiesKHR::MemoryWin32HandlePropertiesKHR(const MemoryWin32HandlePropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryWin32HandlePropertiesKHR& MemoryWin32HandlePropertiesKHR::operator=(const MemoryWin32HandlePropertiesKHR& 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;
+}
+
+MemoryWin32HandlePropertiesKHR::~MemoryWin32HandlePropertiesKHR() { FreePnextChain(pNext); }
+
+void MemoryWin32HandlePropertiesKHR::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 MemoryWin32HandlePropertiesKHR::initialize(const MemoryWin32HandlePropertiesKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryGetWin32HandleInfoKHR::MemoryGetWin32HandleInfoKHR(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);
+    }
+}
+
+MemoryGetWin32HandleInfoKHR::MemoryGetWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), memory(), handleType() {}
+
+MemoryGetWin32HandleInfoKHR::MemoryGetWin32HandleInfoKHR(const MemoryGetWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryGetWin32HandleInfoKHR& MemoryGetWin32HandleInfoKHR::operator=(const MemoryGetWin32HandleInfoKHR& 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;
+}
+
+MemoryGetWin32HandleInfoKHR::~MemoryGetWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void MemoryGetWin32HandleInfoKHR::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 MemoryGetWin32HandleInfoKHR::initialize(const MemoryGetWin32HandleInfoKHR* 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
+
+ImportMemoryFdInfoKHR::ImportMemoryFdInfoKHR(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);
+    }
+}
+
+ImportMemoryFdInfoKHR::ImportMemoryFdInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR), pNext(nullptr), handleType(), fd() {}
+
+ImportMemoryFdInfoKHR::ImportMemoryFdInfoKHR(const ImportMemoryFdInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    fd = copy_src.fd;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImportMemoryFdInfoKHR& ImportMemoryFdInfoKHR::operator=(const ImportMemoryFdInfoKHR& 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;
+}
+
+ImportMemoryFdInfoKHR::~ImportMemoryFdInfoKHR() { FreePnextChain(pNext); }
+
+void ImportMemoryFdInfoKHR::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 ImportMemoryFdInfoKHR::initialize(const ImportMemoryFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    fd = copy_src->fd;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryFdPropertiesKHR::MemoryFdPropertiesKHR(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);
+    }
+}
+
+MemoryFdPropertiesKHR::MemoryFdPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR), pNext(nullptr), memoryTypeBits() {}
+
+MemoryFdPropertiesKHR::MemoryFdPropertiesKHR(const MemoryFdPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryFdPropertiesKHR& MemoryFdPropertiesKHR::operator=(const MemoryFdPropertiesKHR& 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;
+}
+
+MemoryFdPropertiesKHR::~MemoryFdPropertiesKHR() { FreePnextChain(pNext); }
+
+void MemoryFdPropertiesKHR::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 MemoryFdPropertiesKHR::initialize(const MemoryFdPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryGetFdInfoKHR::MemoryGetFdInfoKHR(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);
+    }
+}
+
+MemoryGetFdInfoKHR::MemoryGetFdInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR), pNext(nullptr), memory(), handleType() {}
+
+MemoryGetFdInfoKHR::MemoryGetFdInfoKHR(const MemoryGetFdInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryGetFdInfoKHR& MemoryGetFdInfoKHR::operator=(const MemoryGetFdInfoKHR& 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;
+}
+
+MemoryGetFdInfoKHR::~MemoryGetFdInfoKHR() { FreePnextChain(pNext); }
+
+void MemoryGetFdInfoKHR::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 MemoryGetFdInfoKHR::initialize(const MemoryGetFdInfoKHR* 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
+
+Win32KeyedMutexAcquireReleaseInfoKHR::Win32KeyedMutexAcquireReleaseInfoKHR(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);
+    }
+}
+
+Win32KeyedMutexAcquireReleaseInfoKHR::Win32KeyedMutexAcquireReleaseInfoKHR()
+    : 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) {}
+
+Win32KeyedMutexAcquireReleaseInfoKHR::Win32KeyedMutexAcquireReleaseInfoKHR(const Win32KeyedMutexAcquireReleaseInfoKHR& 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);
+    }
+}
+
+Win32KeyedMutexAcquireReleaseInfoKHR& Win32KeyedMutexAcquireReleaseInfoKHR::operator=(
+    const Win32KeyedMutexAcquireReleaseInfoKHR& 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;
+}
+
+Win32KeyedMutexAcquireReleaseInfoKHR::~Win32KeyedMutexAcquireReleaseInfoKHR() {
+    if (pAcquireSyncs) delete[] pAcquireSyncs;
+    if (pAcquireKeys) delete[] pAcquireKeys;
+    if (pAcquireTimeouts) delete[] pAcquireTimeouts;
+    if (pReleaseSyncs) delete[] pReleaseSyncs;
+    if (pReleaseKeys) delete[] pReleaseKeys;
+    FreePnextChain(pNext);
+}
+
+void Win32KeyedMutexAcquireReleaseInfoKHR::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 Win32KeyedMutexAcquireReleaseInfoKHR::initialize(const Win32KeyedMutexAcquireReleaseInfoKHR* 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);
+    }
+}
+
+ImportSemaphoreWin32HandleInfoKHR::ImportSemaphoreWin32HandleInfoKHR(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);
+    }
+}
+
+ImportSemaphoreWin32HandleInfoKHR::ImportSemaphoreWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR),
+      pNext(nullptr),
+      semaphore(),
+      flags(),
+      handleType(),
+      handle(),
+      name() {}
+
+ImportSemaphoreWin32HandleInfoKHR::ImportSemaphoreWin32HandleInfoKHR(const ImportSemaphoreWin32HandleInfoKHR& 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);
+}
+
+ImportSemaphoreWin32HandleInfoKHR& ImportSemaphoreWin32HandleInfoKHR::operator=(const ImportSemaphoreWin32HandleInfoKHR& 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;
+}
+
+ImportSemaphoreWin32HandleInfoKHR::~ImportSemaphoreWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void ImportSemaphoreWin32HandleInfoKHR::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 ImportSemaphoreWin32HandleInfoKHR::initialize(const ImportSemaphoreWin32HandleInfoKHR* 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);
+}
+
+ExportSemaphoreWin32HandleInfoKHR::ExportSemaphoreWin32HandleInfoKHR(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);
+    }
+}
+
+ExportSemaphoreWin32HandleInfoKHR::ExportSemaphoreWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {}
+
+ExportSemaphoreWin32HandleInfoKHR::ExportSemaphoreWin32HandleInfoKHR(const ExportSemaphoreWin32HandleInfoKHR& 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);
+    }
+}
+
+ExportSemaphoreWin32HandleInfoKHR& ExportSemaphoreWin32HandleInfoKHR::operator=(const ExportSemaphoreWin32HandleInfoKHR& 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;
+}
+
+ExportSemaphoreWin32HandleInfoKHR::~ExportSemaphoreWin32HandleInfoKHR() {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+}
+
+void ExportSemaphoreWin32HandleInfoKHR::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 ExportSemaphoreWin32HandleInfoKHR::initialize(const ExportSemaphoreWin32HandleInfoKHR* 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);
+    }
+}
+
+D3D12FenceSubmitInfoKHR::D3D12FenceSubmitInfoKHR(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);
+    }
+}
+
+D3D12FenceSubmitInfoKHR::D3D12FenceSubmitInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR),
+      pNext(nullptr),
+      waitSemaphoreValuesCount(),
+      pWaitSemaphoreValues(nullptr),
+      signalSemaphoreValuesCount(),
+      pSignalSemaphoreValues(nullptr) {}
+
+D3D12FenceSubmitInfoKHR::D3D12FenceSubmitInfoKHR(const D3D12FenceSubmitInfoKHR& 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);
+    }
+}
+
+D3D12FenceSubmitInfoKHR& D3D12FenceSubmitInfoKHR::operator=(const D3D12FenceSubmitInfoKHR& 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;
+}
+
+D3D12FenceSubmitInfoKHR::~D3D12FenceSubmitInfoKHR() {
+    if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues;
+    if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues;
+    FreePnextChain(pNext);
+}
+
+void D3D12FenceSubmitInfoKHR::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 D3D12FenceSubmitInfoKHR::initialize(const D3D12FenceSubmitInfoKHR* 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);
+    }
+}
+
+SemaphoreGetWin32HandleInfoKHR::SemaphoreGetWin32HandleInfoKHR(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);
+    }
+}
+
+SemaphoreGetWin32HandleInfoKHR::SemaphoreGetWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), semaphore(), handleType() {}
+
+SemaphoreGetWin32HandleInfoKHR::SemaphoreGetWin32HandleInfoKHR(const SemaphoreGetWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SemaphoreGetWin32HandleInfoKHR& SemaphoreGetWin32HandleInfoKHR::operator=(const SemaphoreGetWin32HandleInfoKHR& 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;
+}
+
+SemaphoreGetWin32HandleInfoKHR::~SemaphoreGetWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void SemaphoreGetWin32HandleInfoKHR::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 SemaphoreGetWin32HandleInfoKHR::initialize(const SemaphoreGetWin32HandleInfoKHR* 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
+
+ImportSemaphoreFdInfoKHR::ImportSemaphoreFdInfoKHR(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);
+    }
+}
+
+ImportSemaphoreFdInfoKHR::ImportSemaphoreFdInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR), pNext(nullptr), semaphore(), flags(), handleType(), fd() {}
+
+ImportSemaphoreFdInfoKHR::ImportSemaphoreFdInfoKHR(const ImportSemaphoreFdInfoKHR& 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);
+}
+
+ImportSemaphoreFdInfoKHR& ImportSemaphoreFdInfoKHR::operator=(const ImportSemaphoreFdInfoKHR& 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;
+}
+
+ImportSemaphoreFdInfoKHR::~ImportSemaphoreFdInfoKHR() { FreePnextChain(pNext); }
+
+void ImportSemaphoreFdInfoKHR::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 ImportSemaphoreFdInfoKHR::initialize(const ImportSemaphoreFdInfoKHR* 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);
+}
+
+SemaphoreGetFdInfoKHR::SemaphoreGetFdInfoKHR(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);
+    }
+}
+
+SemaphoreGetFdInfoKHR::SemaphoreGetFdInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR), pNext(nullptr), semaphore(), handleType() {}
+
+SemaphoreGetFdInfoKHR::SemaphoreGetFdInfoKHR(const SemaphoreGetFdInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SemaphoreGetFdInfoKHR& SemaphoreGetFdInfoKHR::operator=(const SemaphoreGetFdInfoKHR& 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;
+}
+
+SemaphoreGetFdInfoKHR::~SemaphoreGetFdInfoKHR() { FreePnextChain(pNext); }
+
+void SemaphoreGetFdInfoKHR::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 SemaphoreGetFdInfoKHR::initialize(const SemaphoreGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePushDescriptorPropertiesKHR::PhysicalDevicePushDescriptorPropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDevicePushDescriptorPropertiesKHR::PhysicalDevicePushDescriptorPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR), pNext(nullptr), maxPushDescriptors() {}
+
+PhysicalDevicePushDescriptorPropertiesKHR::PhysicalDevicePushDescriptorPropertiesKHR(
+    const PhysicalDevicePushDescriptorPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxPushDescriptors = copy_src.maxPushDescriptors;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePushDescriptorPropertiesKHR& PhysicalDevicePushDescriptorPropertiesKHR::operator=(
+    const PhysicalDevicePushDescriptorPropertiesKHR& 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;
+}
+
+PhysicalDevicePushDescriptorPropertiesKHR::~PhysicalDevicePushDescriptorPropertiesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDevicePushDescriptorPropertiesKHR::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 PhysicalDevicePushDescriptorPropertiesKHR::initialize(const PhysicalDevicePushDescriptorPropertiesKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxPushDescriptors = copy_src->maxPushDescriptors;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PresentRegionKHR::PresentRegionKHR(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);
+    }
+}
+
+PresentRegionKHR::PresentRegionKHR() : rectangleCount(), pRectangles(nullptr) {}
+
+PresentRegionKHR::PresentRegionKHR(const PresentRegionKHR& 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);
+    }
+}
+
+PresentRegionKHR& PresentRegionKHR::operator=(const PresentRegionKHR& 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;
+}
+
+PresentRegionKHR::~PresentRegionKHR() {
+    if (pRectangles) delete[] pRectangles;
+}
+
+void PresentRegionKHR::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 PresentRegionKHR::initialize(const PresentRegionKHR* 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);
+    }
+}
+
+PresentRegionsKHR::PresentRegionsKHR(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 PresentRegionKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+PresentRegionsKHR::PresentRegionsKHR()
+    : sType(VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR), pNext(nullptr), swapchainCount(), pRegions(nullptr) {}
+
+PresentRegionsKHR::PresentRegionsKHR(const PresentRegionsKHR& copy_src) {
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (swapchainCount && copy_src.pRegions) {
+        pRegions = new PresentRegionKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+PresentRegionsKHR& PresentRegionsKHR::operator=(const PresentRegionsKHR& 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 PresentRegionKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+PresentRegionsKHR::~PresentRegionsKHR() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void PresentRegionsKHR::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 PresentRegionKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void PresentRegionsKHR::initialize(const PresentRegionsKHR* 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 PresentRegionKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+SharedPresentSurfaceCapabilitiesKHR::SharedPresentSurfaceCapabilitiesKHR(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);
+    }
+}
+
+SharedPresentSurfaceCapabilitiesKHR::SharedPresentSurfaceCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR), pNext(nullptr), sharedPresentSupportedUsageFlags() {}
+
+SharedPresentSurfaceCapabilitiesKHR::SharedPresentSurfaceCapabilitiesKHR(const SharedPresentSurfaceCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    sharedPresentSupportedUsageFlags = copy_src.sharedPresentSupportedUsageFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SharedPresentSurfaceCapabilitiesKHR& SharedPresentSurfaceCapabilitiesKHR::operator=(
+    const SharedPresentSurfaceCapabilitiesKHR& 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;
+}
+
+SharedPresentSurfaceCapabilitiesKHR::~SharedPresentSurfaceCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void SharedPresentSurfaceCapabilitiesKHR::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 SharedPresentSurfaceCapabilitiesKHR::initialize(const SharedPresentSurfaceCapabilitiesKHR* 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
+
+ImportFenceWin32HandleInfoKHR::ImportFenceWin32HandleInfoKHR(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);
+    }
+}
+
+ImportFenceWin32HandleInfoKHR::ImportFenceWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR),
+      pNext(nullptr),
+      fence(),
+      flags(),
+      handleType(),
+      handle(),
+      name() {}
+
+ImportFenceWin32HandleInfoKHR::ImportFenceWin32HandleInfoKHR(const ImportFenceWin32HandleInfoKHR& 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);
+}
+
+ImportFenceWin32HandleInfoKHR& ImportFenceWin32HandleInfoKHR::operator=(const ImportFenceWin32HandleInfoKHR& 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;
+}
+
+ImportFenceWin32HandleInfoKHR::~ImportFenceWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void ImportFenceWin32HandleInfoKHR::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 ImportFenceWin32HandleInfoKHR::initialize(const ImportFenceWin32HandleInfoKHR* 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);
+}
+
+ExportFenceWin32HandleInfoKHR::ExportFenceWin32HandleInfoKHR(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);
+    }
+}
+
+ExportFenceWin32HandleInfoKHR::ExportFenceWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {}
+
+ExportFenceWin32HandleInfoKHR::ExportFenceWin32HandleInfoKHR(const ExportFenceWin32HandleInfoKHR& 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);
+    }
+}
+
+ExportFenceWin32HandleInfoKHR& ExportFenceWin32HandleInfoKHR::operator=(const ExportFenceWin32HandleInfoKHR& 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;
+}
+
+ExportFenceWin32HandleInfoKHR::~ExportFenceWin32HandleInfoKHR() {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+}
+
+void ExportFenceWin32HandleInfoKHR::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 ExportFenceWin32HandleInfoKHR::initialize(const ExportFenceWin32HandleInfoKHR* 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);
+    }
+}
+
+FenceGetWin32HandleInfoKHR::FenceGetWin32HandleInfoKHR(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);
+    }
+}
+
+FenceGetWin32HandleInfoKHR::FenceGetWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), fence(), handleType() {}
+
+FenceGetWin32HandleInfoKHR::FenceGetWin32HandleInfoKHR(const FenceGetWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    fence = copy_src.fence;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+FenceGetWin32HandleInfoKHR& FenceGetWin32HandleInfoKHR::operator=(const FenceGetWin32HandleInfoKHR& 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;
+}
+
+FenceGetWin32HandleInfoKHR::~FenceGetWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void FenceGetWin32HandleInfoKHR::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 FenceGetWin32HandleInfoKHR::initialize(const FenceGetWin32HandleInfoKHR* 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
+
+ImportFenceFdInfoKHR::ImportFenceFdInfoKHR(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);
+    }
+}
+
+ImportFenceFdInfoKHR::ImportFenceFdInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR), pNext(nullptr), fence(), flags(), handleType(), fd() {}
+
+ImportFenceFdInfoKHR::ImportFenceFdInfoKHR(const ImportFenceFdInfoKHR& 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);
+}
+
+ImportFenceFdInfoKHR& ImportFenceFdInfoKHR::operator=(const ImportFenceFdInfoKHR& 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;
+}
+
+ImportFenceFdInfoKHR::~ImportFenceFdInfoKHR() { FreePnextChain(pNext); }
+
+void ImportFenceFdInfoKHR::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 ImportFenceFdInfoKHR::initialize(const ImportFenceFdInfoKHR* 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);
+}
+
+FenceGetFdInfoKHR::FenceGetFdInfoKHR(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);
+    }
+}
+
+FenceGetFdInfoKHR::FenceGetFdInfoKHR() : sType(VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR), pNext(nullptr), fence(), handleType() {}
+
+FenceGetFdInfoKHR::FenceGetFdInfoKHR(const FenceGetFdInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    fence = copy_src.fence;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+FenceGetFdInfoKHR& FenceGetFdInfoKHR::operator=(const FenceGetFdInfoKHR& 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;
+}
+
+FenceGetFdInfoKHR::~FenceGetFdInfoKHR() { FreePnextChain(pNext); }
+
+void FenceGetFdInfoKHR::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 FenceGetFdInfoKHR::initialize(const FenceGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fence = copy_src->fence;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePerformanceQueryFeaturesKHR::PhysicalDevicePerformanceQueryFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDevicePerformanceQueryFeaturesKHR::PhysicalDevicePerformanceQueryFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR),
+      pNext(nullptr),
+      performanceCounterQueryPools(),
+      performanceCounterMultipleQueryPools() {}
+
+PhysicalDevicePerformanceQueryFeaturesKHR::PhysicalDevicePerformanceQueryFeaturesKHR(
+    const PhysicalDevicePerformanceQueryFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    performanceCounterQueryPools = copy_src.performanceCounterQueryPools;
+    performanceCounterMultipleQueryPools = copy_src.performanceCounterMultipleQueryPools;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePerformanceQueryFeaturesKHR& PhysicalDevicePerformanceQueryFeaturesKHR::operator=(
+    const PhysicalDevicePerformanceQueryFeaturesKHR& 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;
+}
+
+PhysicalDevicePerformanceQueryFeaturesKHR::~PhysicalDevicePerformanceQueryFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDevicePerformanceQueryFeaturesKHR::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 PhysicalDevicePerformanceQueryFeaturesKHR::initialize(const PhysicalDevicePerformanceQueryFeaturesKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    performanceCounterQueryPools = copy_src->performanceCounterQueryPools;
+    performanceCounterMultipleQueryPools = copy_src->performanceCounterMultipleQueryPools;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePerformanceQueryPropertiesKHR::PhysicalDevicePerformanceQueryPropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDevicePerformanceQueryPropertiesKHR::PhysicalDevicePerformanceQueryPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR), pNext(nullptr), allowCommandBufferQueryCopies() {}
+
+PhysicalDevicePerformanceQueryPropertiesKHR::PhysicalDevicePerformanceQueryPropertiesKHR(
+    const PhysicalDevicePerformanceQueryPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    allowCommandBufferQueryCopies = copy_src.allowCommandBufferQueryCopies;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePerformanceQueryPropertiesKHR& PhysicalDevicePerformanceQueryPropertiesKHR::operator=(
+    const PhysicalDevicePerformanceQueryPropertiesKHR& 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;
+}
+
+PhysicalDevicePerformanceQueryPropertiesKHR::~PhysicalDevicePerformanceQueryPropertiesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDevicePerformanceQueryPropertiesKHR::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 PhysicalDevicePerformanceQueryPropertiesKHR::initialize(const PhysicalDevicePerformanceQueryPropertiesKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    allowCommandBufferQueryCopies = copy_src->allowCommandBufferQueryCopies;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PerformanceCounterKHR::PerformanceCounterKHR(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];
+    }
+}
+
+PerformanceCounterKHR::PerformanceCounterKHR()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR), pNext(nullptr), unit(), scope(), storage() {}
+
+PerformanceCounterKHR::PerformanceCounterKHR(const PerformanceCounterKHR& 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];
+    }
+}
+
+PerformanceCounterKHR& PerformanceCounterKHR::operator=(const PerformanceCounterKHR& 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;
+}
+
+PerformanceCounterKHR::~PerformanceCounterKHR() { FreePnextChain(pNext); }
+
+void PerformanceCounterKHR::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 PerformanceCounterKHR::initialize(const PerformanceCounterKHR* 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];
+    }
+}
+
+PerformanceCounterDescriptionKHR::PerformanceCounterDescriptionKHR(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];
+    }
+}
+
+PerformanceCounterDescriptionKHR::PerformanceCounterDescriptionKHR()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR), pNext(nullptr), flags() {}
+
+PerformanceCounterDescriptionKHR::PerformanceCounterDescriptionKHR(const PerformanceCounterDescriptionKHR& 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];
+    }
+}
+
+PerformanceCounterDescriptionKHR& PerformanceCounterDescriptionKHR::operator=(const PerformanceCounterDescriptionKHR& 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;
+}
+
+PerformanceCounterDescriptionKHR::~PerformanceCounterDescriptionKHR() { FreePnextChain(pNext); }
+
+void PerformanceCounterDescriptionKHR::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 PerformanceCounterDescriptionKHR::initialize(const PerformanceCounterDescriptionKHR* 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];
+    }
+}
+
+QueryPoolPerformanceCreateInfoKHR::QueryPoolPerformanceCreateInfoKHR(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);
+    }
+}
+
+QueryPoolPerformanceCreateInfoKHR::QueryPoolPerformanceCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      queueFamilyIndex(),
+      counterIndexCount(),
+      pCounterIndices(nullptr) {}
+
+QueryPoolPerformanceCreateInfoKHR::QueryPoolPerformanceCreateInfoKHR(const QueryPoolPerformanceCreateInfoKHR& 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);
+    }
+}
+
+QueryPoolPerformanceCreateInfoKHR& QueryPoolPerformanceCreateInfoKHR::operator=(const QueryPoolPerformanceCreateInfoKHR& 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;
+}
+
+QueryPoolPerformanceCreateInfoKHR::~QueryPoolPerformanceCreateInfoKHR() {
+    if (pCounterIndices) delete[] pCounterIndices;
+    FreePnextChain(pNext);
+}
+
+void QueryPoolPerformanceCreateInfoKHR::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 QueryPoolPerformanceCreateInfoKHR::initialize(const QueryPoolPerformanceCreateInfoKHR* 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);
+    }
+}
+
+AcquireProfilingLockInfoKHR::AcquireProfilingLockInfoKHR(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);
+    }
+}
+
+AcquireProfilingLockInfoKHR::AcquireProfilingLockInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR), pNext(nullptr), flags(), timeout() {}
+
+AcquireProfilingLockInfoKHR::AcquireProfilingLockInfoKHR(const AcquireProfilingLockInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    timeout = copy_src.timeout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AcquireProfilingLockInfoKHR& AcquireProfilingLockInfoKHR::operator=(const AcquireProfilingLockInfoKHR& 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;
+}
+
+AcquireProfilingLockInfoKHR::~AcquireProfilingLockInfoKHR() { FreePnextChain(pNext); }
+
+void AcquireProfilingLockInfoKHR::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 AcquireProfilingLockInfoKHR::initialize(const AcquireProfilingLockInfoKHR* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    timeout = copy_src->timeout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PerformanceQuerySubmitInfoKHR::PerformanceQuerySubmitInfoKHR(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);
+    }
+}
+
+PerformanceQuerySubmitInfoKHR::PerformanceQuerySubmitInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR), pNext(nullptr), counterPassIndex() {}
+
+PerformanceQuerySubmitInfoKHR::PerformanceQuerySubmitInfoKHR(const PerformanceQuerySubmitInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    counterPassIndex = copy_src.counterPassIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PerformanceQuerySubmitInfoKHR& PerformanceQuerySubmitInfoKHR::operator=(const PerformanceQuerySubmitInfoKHR& 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;
+}
+
+PerformanceQuerySubmitInfoKHR::~PerformanceQuerySubmitInfoKHR() { FreePnextChain(pNext); }
+
+void PerformanceQuerySubmitInfoKHR::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 PerformanceQuerySubmitInfoKHR::initialize(const PerformanceQuerySubmitInfoKHR* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    counterPassIndex = copy_src->counterPassIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceSurfaceInfo2KHR::PhysicalDeviceSurfaceInfo2KHR(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);
+    }
+}
+
+PhysicalDeviceSurfaceInfo2KHR::PhysicalDeviceSurfaceInfo2KHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR), pNext(nullptr), surface() {}
+
+PhysicalDeviceSurfaceInfo2KHR::PhysicalDeviceSurfaceInfo2KHR(const PhysicalDeviceSurfaceInfo2KHR& copy_src) {
+    sType = copy_src.sType;
+    surface = copy_src.surface;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSurfaceInfo2KHR& PhysicalDeviceSurfaceInfo2KHR::operator=(const PhysicalDeviceSurfaceInfo2KHR& 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;
+}
+
+PhysicalDeviceSurfaceInfo2KHR::~PhysicalDeviceSurfaceInfo2KHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSurfaceInfo2KHR::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 PhysicalDeviceSurfaceInfo2KHR::initialize(const PhysicalDeviceSurfaceInfo2KHR* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    surface = copy_src->surface;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SurfaceCapabilities2KHR::SurfaceCapabilities2KHR(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);
+    }
+}
+
+SurfaceCapabilities2KHR::SurfaceCapabilities2KHR()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR), pNext(nullptr), surfaceCapabilities() {}
+
+SurfaceCapabilities2KHR::SurfaceCapabilities2KHR(const SurfaceCapabilities2KHR& copy_src) {
+    sType = copy_src.sType;
+    surfaceCapabilities = copy_src.surfaceCapabilities;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SurfaceCapabilities2KHR& SurfaceCapabilities2KHR::operator=(const SurfaceCapabilities2KHR& 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;
+}
+
+SurfaceCapabilities2KHR::~SurfaceCapabilities2KHR() { FreePnextChain(pNext); }
+
+void SurfaceCapabilities2KHR::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 SurfaceCapabilities2KHR::initialize(const SurfaceCapabilities2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    surfaceCapabilities = copy_src->surfaceCapabilities;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SurfaceFormat2KHR::SurfaceFormat2KHR(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);
+    }
+}
+
+SurfaceFormat2KHR::SurfaceFormat2KHR() : sType(VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR), pNext(nullptr), surfaceFormat() {}
+
+SurfaceFormat2KHR::SurfaceFormat2KHR(const SurfaceFormat2KHR& copy_src) {
+    sType = copy_src.sType;
+    surfaceFormat = copy_src.surfaceFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SurfaceFormat2KHR& SurfaceFormat2KHR::operator=(const SurfaceFormat2KHR& 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;
+}
+
+SurfaceFormat2KHR::~SurfaceFormat2KHR() { FreePnextChain(pNext); }
+
+void SurfaceFormat2KHR::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 SurfaceFormat2KHR::initialize(const SurfaceFormat2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    surfaceFormat = copy_src->surfaceFormat;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DisplayProperties2KHR::DisplayProperties2KHR(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);
+    }
+}
+
+DisplayProperties2KHR::DisplayProperties2KHR() : sType(VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR), pNext(nullptr) {}
+
+DisplayProperties2KHR::DisplayProperties2KHR(const DisplayProperties2KHR& copy_src) {
+    sType = copy_src.sType;
+    displayProperties.initialize(&copy_src.displayProperties);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DisplayProperties2KHR& DisplayProperties2KHR::operator=(const DisplayProperties2KHR& 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;
+}
+
+DisplayProperties2KHR::~DisplayProperties2KHR() { FreePnextChain(pNext); }
+
+void DisplayProperties2KHR::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 DisplayProperties2KHR::initialize(const DisplayProperties2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displayProperties.initialize(&copy_src->displayProperties);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DisplayPlaneProperties2KHR::DisplayPlaneProperties2KHR(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);
+    }
+}
+
+DisplayPlaneProperties2KHR::DisplayPlaneProperties2KHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR), pNext(nullptr), displayPlaneProperties() {}
+
+DisplayPlaneProperties2KHR::DisplayPlaneProperties2KHR(const DisplayPlaneProperties2KHR& copy_src) {
+    sType = copy_src.sType;
+    displayPlaneProperties = copy_src.displayPlaneProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DisplayPlaneProperties2KHR& DisplayPlaneProperties2KHR::operator=(const DisplayPlaneProperties2KHR& 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;
+}
+
+DisplayPlaneProperties2KHR::~DisplayPlaneProperties2KHR() { FreePnextChain(pNext); }
+
+void DisplayPlaneProperties2KHR::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 DisplayPlaneProperties2KHR::initialize(const DisplayPlaneProperties2KHR* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displayPlaneProperties = copy_src->displayPlaneProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DisplayModeProperties2KHR::DisplayModeProperties2KHR(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);
+    }
+}
+
+DisplayModeProperties2KHR::DisplayModeProperties2KHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR), pNext(nullptr), displayModeProperties() {}
+
+DisplayModeProperties2KHR::DisplayModeProperties2KHR(const DisplayModeProperties2KHR& copy_src) {
+    sType = copy_src.sType;
+    displayModeProperties = copy_src.displayModeProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DisplayModeProperties2KHR& DisplayModeProperties2KHR::operator=(const DisplayModeProperties2KHR& 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;
+}
+
+DisplayModeProperties2KHR::~DisplayModeProperties2KHR() { FreePnextChain(pNext); }
+
+void DisplayModeProperties2KHR::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 DisplayModeProperties2KHR::initialize(const DisplayModeProperties2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displayModeProperties = copy_src->displayModeProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DisplayPlaneInfo2KHR::DisplayPlaneInfo2KHR(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);
+    }
+}
+
+DisplayPlaneInfo2KHR::DisplayPlaneInfo2KHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR), pNext(nullptr), mode(), planeIndex() {}
+
+DisplayPlaneInfo2KHR::DisplayPlaneInfo2KHR(const DisplayPlaneInfo2KHR& copy_src) {
+    sType = copy_src.sType;
+    mode = copy_src.mode;
+    planeIndex = copy_src.planeIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DisplayPlaneInfo2KHR& DisplayPlaneInfo2KHR::operator=(const DisplayPlaneInfo2KHR& 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;
+}
+
+DisplayPlaneInfo2KHR::~DisplayPlaneInfo2KHR() { FreePnextChain(pNext); }
+
+void DisplayPlaneInfo2KHR::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 DisplayPlaneInfo2KHR::initialize(const DisplayPlaneInfo2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mode = copy_src->mode;
+    planeIndex = copy_src->planeIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DisplayPlaneCapabilities2KHR::DisplayPlaneCapabilities2KHR(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);
+    }
+}
+
+DisplayPlaneCapabilities2KHR::DisplayPlaneCapabilities2KHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR), pNext(nullptr), capabilities() {}
+
+DisplayPlaneCapabilities2KHR::DisplayPlaneCapabilities2KHR(const DisplayPlaneCapabilities2KHR& copy_src) {
+    sType = copy_src.sType;
+    capabilities = copy_src.capabilities;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DisplayPlaneCapabilities2KHR& DisplayPlaneCapabilities2KHR::operator=(const DisplayPlaneCapabilities2KHR& 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;
+}
+
+DisplayPlaneCapabilities2KHR::~DisplayPlaneCapabilities2KHR() { FreePnextChain(pNext); }
+
+void DisplayPlaneCapabilities2KHR::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 DisplayPlaneCapabilities2KHR::initialize(const DisplayPlaneCapabilities2KHR* 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
+
+PhysicalDevicePortabilitySubsetFeaturesKHR::PhysicalDevicePortabilitySubsetFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDevicePortabilitySubsetFeaturesKHR::PhysicalDevicePortabilitySubsetFeaturesKHR()
+    : 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() {}
+
+PhysicalDevicePortabilitySubsetFeaturesKHR::PhysicalDevicePortabilitySubsetFeaturesKHR(
+    const PhysicalDevicePortabilitySubsetFeaturesKHR& 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);
+}
+
+PhysicalDevicePortabilitySubsetFeaturesKHR& PhysicalDevicePortabilitySubsetFeaturesKHR::operator=(
+    const PhysicalDevicePortabilitySubsetFeaturesKHR& 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;
+}
+
+PhysicalDevicePortabilitySubsetFeaturesKHR::~PhysicalDevicePortabilitySubsetFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDevicePortabilitySubsetFeaturesKHR::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 PhysicalDevicePortabilitySubsetFeaturesKHR::initialize(const PhysicalDevicePortabilitySubsetFeaturesKHR* 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);
+}
+
+PhysicalDevicePortabilitySubsetPropertiesKHR::PhysicalDevicePortabilitySubsetPropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDevicePortabilitySubsetPropertiesKHR::PhysicalDevicePortabilitySubsetPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR),
+      pNext(nullptr),
+      minVertexInputBindingStrideAlignment() {}
+
+PhysicalDevicePortabilitySubsetPropertiesKHR::PhysicalDevicePortabilitySubsetPropertiesKHR(
+    const PhysicalDevicePortabilitySubsetPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    minVertexInputBindingStrideAlignment = copy_src.minVertexInputBindingStrideAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePortabilitySubsetPropertiesKHR& PhysicalDevicePortabilitySubsetPropertiesKHR::operator=(
+    const PhysicalDevicePortabilitySubsetPropertiesKHR& 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;
+}
+
+PhysicalDevicePortabilitySubsetPropertiesKHR::~PhysicalDevicePortabilitySubsetPropertiesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDevicePortabilitySubsetPropertiesKHR::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 PhysicalDevicePortabilitySubsetPropertiesKHR::initialize(const PhysicalDevicePortabilitySubsetPropertiesKHR* 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
+
+PhysicalDeviceShaderClockFeaturesKHR::PhysicalDeviceShaderClockFeaturesKHR(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);
+    }
+}
+
+PhysicalDeviceShaderClockFeaturesKHR::PhysicalDeviceShaderClockFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR),
+      pNext(nullptr),
+      shaderSubgroupClock(),
+      shaderDeviceClock() {}
+
+PhysicalDeviceShaderClockFeaturesKHR::PhysicalDeviceShaderClockFeaturesKHR(const PhysicalDeviceShaderClockFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderSubgroupClock = copy_src.shaderSubgroupClock;
+    shaderDeviceClock = copy_src.shaderDeviceClock;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderClockFeaturesKHR& PhysicalDeviceShaderClockFeaturesKHR::operator=(
+    const PhysicalDeviceShaderClockFeaturesKHR& 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;
+}
+
+PhysicalDeviceShaderClockFeaturesKHR::~PhysicalDeviceShaderClockFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderClockFeaturesKHR::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 PhysicalDeviceShaderClockFeaturesKHR::initialize(const PhysicalDeviceShaderClockFeaturesKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSubgroupClock = copy_src->shaderSubgroupClock;
+    shaderDeviceClock = copy_src->shaderDeviceClock;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoDecodeH265ProfileInfoKHR::VideoDecodeH265ProfileInfoKHR(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);
+    }
+}
+
+VideoDecodeH265ProfileInfoKHR::VideoDecodeH265ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {}
+
+VideoDecodeH265ProfileInfoKHR::VideoDecodeH265ProfileInfoKHR(const VideoDecodeH265ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoDecodeH265ProfileInfoKHR& VideoDecodeH265ProfileInfoKHR::operator=(const VideoDecodeH265ProfileInfoKHR& 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;
+}
+
+VideoDecodeH265ProfileInfoKHR::~VideoDecodeH265ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void VideoDecodeH265ProfileInfoKHR::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 VideoDecodeH265ProfileInfoKHR::initialize(const VideoDecodeH265ProfileInfoKHR* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfileIdc = copy_src->stdProfileIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoDecodeH265CapabilitiesKHR::VideoDecodeH265CapabilitiesKHR(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);
+    }
+}
+
+VideoDecodeH265CapabilitiesKHR::VideoDecodeH265CapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR), pNext(nullptr), maxLevelIdc() {}
+
+VideoDecodeH265CapabilitiesKHR::VideoDecodeH265CapabilitiesKHR(const VideoDecodeH265CapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoDecodeH265CapabilitiesKHR& VideoDecodeH265CapabilitiesKHR::operator=(const VideoDecodeH265CapabilitiesKHR& 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;
+}
+
+VideoDecodeH265CapabilitiesKHR::~VideoDecodeH265CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void VideoDecodeH265CapabilitiesKHR::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 VideoDecodeH265CapabilitiesKHR::initialize(const VideoDecodeH265CapabilitiesKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxLevelIdc = copy_src->maxLevelIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoDecodeH265SessionParametersAddInfoKHR::VideoDecodeH265SessionParametersAddInfoKHR(
+    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);
+    }
+}
+
+VideoDecodeH265SessionParametersAddInfoKHR::VideoDecodeH265SessionParametersAddInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR),
+      pNext(nullptr),
+      stdVPSCount(),
+      pStdVPSs(nullptr),
+      stdSPSCount(),
+      pStdSPSs(nullptr),
+      stdPPSCount(),
+      pStdPPSs(nullptr) {}
+
+VideoDecodeH265SessionParametersAddInfoKHR::VideoDecodeH265SessionParametersAddInfoKHR(
+    const VideoDecodeH265SessionParametersAddInfoKHR& 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);
+    }
+}
+
+VideoDecodeH265SessionParametersAddInfoKHR& VideoDecodeH265SessionParametersAddInfoKHR::operator=(
+    const VideoDecodeH265SessionParametersAddInfoKHR& 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;
+}
+
+VideoDecodeH265SessionParametersAddInfoKHR::~VideoDecodeH265SessionParametersAddInfoKHR() {
+    if (pStdVPSs) delete[] pStdVPSs;
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeH265SessionParametersAddInfoKHR::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 VideoDecodeH265SessionParametersAddInfoKHR::initialize(const VideoDecodeH265SessionParametersAddInfoKHR* 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);
+    }
+}
+
+VideoDecodeH265SessionParametersCreateInfoKHR::VideoDecodeH265SessionParametersCreateInfoKHR(
+    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 VideoDecodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+VideoDecodeH265SessionParametersCreateInfoKHR::VideoDecodeH265SessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      maxStdVPSCount(),
+      maxStdSPSCount(),
+      maxStdPPSCount(),
+      pParametersAddInfo(nullptr) {}
+
+VideoDecodeH265SessionParametersCreateInfoKHR::VideoDecodeH265SessionParametersCreateInfoKHR(
+    const VideoDecodeH265SessionParametersCreateInfoKHR& 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 VideoDecodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+}
+
+VideoDecodeH265SessionParametersCreateInfoKHR& VideoDecodeH265SessionParametersCreateInfoKHR::operator=(
+    const VideoDecodeH265SessionParametersCreateInfoKHR& 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 VideoDecodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+
+    return *this;
+}
+
+VideoDecodeH265SessionParametersCreateInfoKHR::~VideoDecodeH265SessionParametersCreateInfoKHR() {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeH265SessionParametersCreateInfoKHR::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 VideoDecodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+void VideoDecodeH265SessionParametersCreateInfoKHR::initialize(const VideoDecodeH265SessionParametersCreateInfoKHR* 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 VideoDecodeH265SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo);
+}
+
+VideoDecodeH265PictureInfoKHR::VideoDecodeH265PictureInfoKHR(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);
+    }
+}
+
+VideoDecodeH265PictureInfoKHR::VideoDecodeH265PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      pStdPictureInfo(nullptr),
+      sliceSegmentCount(),
+      pSliceSegmentOffsets(nullptr) {}
+
+VideoDecodeH265PictureInfoKHR::VideoDecodeH265PictureInfoKHR(const VideoDecodeH265PictureInfoKHR& 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);
+    }
+}
+
+VideoDecodeH265PictureInfoKHR& VideoDecodeH265PictureInfoKHR::operator=(const VideoDecodeH265PictureInfoKHR& 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;
+}
+
+VideoDecodeH265PictureInfoKHR::~VideoDecodeH265PictureInfoKHR() {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pSliceSegmentOffsets) delete[] pSliceSegmentOffsets;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeH265PictureInfoKHR::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 VideoDecodeH265PictureInfoKHR::initialize(const VideoDecodeH265PictureInfoKHR* 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);
+    }
+}
+
+VideoDecodeH265DpbSlotInfoKHR::VideoDecodeH265DpbSlotInfoKHR(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);
+    }
+}
+
+VideoDecodeH265DpbSlotInfoKHR::VideoDecodeH265DpbSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {}
+
+VideoDecodeH265DpbSlotInfoKHR::VideoDecodeH265DpbSlotInfoKHR(const VideoDecodeH265DpbSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+}
+
+VideoDecodeH265DpbSlotInfoKHR& VideoDecodeH265DpbSlotInfoKHR::operator=(const VideoDecodeH265DpbSlotInfoKHR& 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;
+}
+
+VideoDecodeH265DpbSlotInfoKHR::~VideoDecodeH265DpbSlotInfoKHR() {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeH265DpbSlotInfoKHR::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 VideoDecodeH265DpbSlotInfoKHR::initialize(const VideoDecodeH265DpbSlotInfoKHR* 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);
+    }
+}
+
+DeviceQueueGlobalPriorityCreateInfoKHR::DeviceQueueGlobalPriorityCreateInfoKHR(
+    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);
+    }
+}
+
+DeviceQueueGlobalPriorityCreateInfoKHR::DeviceQueueGlobalPriorityCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR), pNext(nullptr), globalPriority() {}
+
+DeviceQueueGlobalPriorityCreateInfoKHR::DeviceQueueGlobalPriorityCreateInfoKHR(
+    const DeviceQueueGlobalPriorityCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    globalPriority = copy_src.globalPriority;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceQueueGlobalPriorityCreateInfoKHR& DeviceQueueGlobalPriorityCreateInfoKHR::operator=(
+    const DeviceQueueGlobalPriorityCreateInfoKHR& 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;
+}
+
+DeviceQueueGlobalPriorityCreateInfoKHR::~DeviceQueueGlobalPriorityCreateInfoKHR() { FreePnextChain(pNext); }
+
+void DeviceQueueGlobalPriorityCreateInfoKHR::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 DeviceQueueGlobalPriorityCreateInfoKHR::initialize(const DeviceQueueGlobalPriorityCreateInfoKHR* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    globalPriority = copy_src->globalPriority;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceGlobalPriorityQueryFeaturesKHR::PhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceGlobalPriorityQueryFeaturesKHR::PhysicalDeviceGlobalPriorityQueryFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR), pNext(nullptr), globalPriorityQuery() {}
+
+PhysicalDeviceGlobalPriorityQueryFeaturesKHR::PhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    const PhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    globalPriorityQuery = copy_src.globalPriorityQuery;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceGlobalPriorityQueryFeaturesKHR& PhysicalDeviceGlobalPriorityQueryFeaturesKHR::operator=(
+    const PhysicalDeviceGlobalPriorityQueryFeaturesKHR& 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;
+}
+
+PhysicalDeviceGlobalPriorityQueryFeaturesKHR::~PhysicalDeviceGlobalPriorityQueryFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceGlobalPriorityQueryFeaturesKHR::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 PhysicalDeviceGlobalPriorityQueryFeaturesKHR::initialize(const PhysicalDeviceGlobalPriorityQueryFeaturesKHR* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    globalPriorityQuery = copy_src->globalPriorityQuery;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+QueueFamilyGlobalPriorityPropertiesKHR::QueueFamilyGlobalPriorityPropertiesKHR(
+    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];
+    }
+}
+
+QueueFamilyGlobalPriorityPropertiesKHR::QueueFamilyGlobalPriorityPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR), pNext(nullptr), priorityCount() {}
+
+QueueFamilyGlobalPriorityPropertiesKHR::QueueFamilyGlobalPriorityPropertiesKHR(
+    const QueueFamilyGlobalPriorityPropertiesKHR& 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];
+    }
+}
+
+QueueFamilyGlobalPriorityPropertiesKHR& QueueFamilyGlobalPriorityPropertiesKHR::operator=(
+    const QueueFamilyGlobalPriorityPropertiesKHR& 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;
+}
+
+QueueFamilyGlobalPriorityPropertiesKHR::~QueueFamilyGlobalPriorityPropertiesKHR() { FreePnextChain(pNext); }
+
+void QueueFamilyGlobalPriorityPropertiesKHR::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 QueueFamilyGlobalPriorityPropertiesKHR::initialize(const QueueFamilyGlobalPriorityPropertiesKHR* 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];
+    }
+}
+
+FragmentShadingRateAttachmentInfoKHR::FragmentShadingRateAttachmentInfoKHR(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 AttachmentReference2(in_struct->pFragmentShadingRateAttachment);
+}
+
+FragmentShadingRateAttachmentInfoKHR::FragmentShadingRateAttachmentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR),
+      pNext(nullptr),
+      pFragmentShadingRateAttachment(nullptr),
+      shadingRateAttachmentTexelSize() {}
+
+FragmentShadingRateAttachmentInfoKHR::FragmentShadingRateAttachmentInfoKHR(const FragmentShadingRateAttachmentInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pFragmentShadingRateAttachment = nullptr;
+    shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pFragmentShadingRateAttachment)
+        pFragmentShadingRateAttachment = new AttachmentReference2(*copy_src.pFragmentShadingRateAttachment);
+}
+
+FragmentShadingRateAttachmentInfoKHR& FragmentShadingRateAttachmentInfoKHR::operator=(
+    const FragmentShadingRateAttachmentInfoKHR& 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 AttachmentReference2(*copy_src.pFragmentShadingRateAttachment);
+
+    return *this;
+}
+
+FragmentShadingRateAttachmentInfoKHR::~FragmentShadingRateAttachmentInfoKHR() {
+    if (pFragmentShadingRateAttachment) delete pFragmentShadingRateAttachment;
+    FreePnextChain(pNext);
+}
+
+void FragmentShadingRateAttachmentInfoKHR::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 AttachmentReference2(in_struct->pFragmentShadingRateAttachment);
+}
+
+void FragmentShadingRateAttachmentInfoKHR::initialize(const FragmentShadingRateAttachmentInfoKHR* 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 AttachmentReference2(*copy_src->pFragmentShadingRateAttachment);
+}
+
+PipelineFragmentShadingRateStateCreateInfoKHR::PipelineFragmentShadingRateStateCreateInfoKHR(
+    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];
+    }
+}
+
+PipelineFragmentShadingRateStateCreateInfoKHR::PipelineFragmentShadingRateStateCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR), pNext(nullptr), fragmentSize() {}
+
+PipelineFragmentShadingRateStateCreateInfoKHR::PipelineFragmentShadingRateStateCreateInfoKHR(
+    const PipelineFragmentShadingRateStateCreateInfoKHR& 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];
+    }
+}
+
+PipelineFragmentShadingRateStateCreateInfoKHR& PipelineFragmentShadingRateStateCreateInfoKHR::operator=(
+    const PipelineFragmentShadingRateStateCreateInfoKHR& 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;
+}
+
+PipelineFragmentShadingRateStateCreateInfoKHR::~PipelineFragmentShadingRateStateCreateInfoKHR() { FreePnextChain(pNext); }
+
+void PipelineFragmentShadingRateStateCreateInfoKHR::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 PipelineFragmentShadingRateStateCreateInfoKHR::initialize(const PipelineFragmentShadingRateStateCreateInfoKHR* 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];
+    }
+}
+
+PhysicalDeviceFragmentShadingRateFeaturesKHR::PhysicalDeviceFragmentShadingRateFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentShadingRateFeaturesKHR::PhysicalDeviceFragmentShadingRateFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR),
+      pNext(nullptr),
+      pipelineFragmentShadingRate(),
+      primitiveFragmentShadingRate(),
+      attachmentFragmentShadingRate() {}
+
+PhysicalDeviceFragmentShadingRateFeaturesKHR::PhysicalDeviceFragmentShadingRateFeaturesKHR(
+    const PhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    pipelineFragmentShadingRate = copy_src.pipelineFragmentShadingRate;
+    primitiveFragmentShadingRate = copy_src.primitiveFragmentShadingRate;
+    attachmentFragmentShadingRate = copy_src.attachmentFragmentShadingRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentShadingRateFeaturesKHR& PhysicalDeviceFragmentShadingRateFeaturesKHR::operator=(
+    const PhysicalDeviceFragmentShadingRateFeaturesKHR& 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;
+}
+
+PhysicalDeviceFragmentShadingRateFeaturesKHR::~PhysicalDeviceFragmentShadingRateFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentShadingRateFeaturesKHR::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 PhysicalDeviceFragmentShadingRateFeaturesKHR::initialize(const PhysicalDeviceFragmentShadingRateFeaturesKHR* 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);
+}
+
+PhysicalDeviceFragmentShadingRatePropertiesKHR::PhysicalDeviceFragmentShadingRatePropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentShadingRatePropertiesKHR::PhysicalDeviceFragmentShadingRatePropertiesKHR()
+    : 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() {}
+
+PhysicalDeviceFragmentShadingRatePropertiesKHR::PhysicalDeviceFragmentShadingRatePropertiesKHR(
+    const PhysicalDeviceFragmentShadingRatePropertiesKHR& 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);
+}
+
+PhysicalDeviceFragmentShadingRatePropertiesKHR& PhysicalDeviceFragmentShadingRatePropertiesKHR::operator=(
+    const PhysicalDeviceFragmentShadingRatePropertiesKHR& 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;
+}
+
+PhysicalDeviceFragmentShadingRatePropertiesKHR::~PhysicalDeviceFragmentShadingRatePropertiesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentShadingRatePropertiesKHR::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 PhysicalDeviceFragmentShadingRatePropertiesKHR::initialize(const PhysicalDeviceFragmentShadingRatePropertiesKHR* 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);
+}
+
+PhysicalDeviceFragmentShadingRateKHR::PhysicalDeviceFragmentShadingRateKHR(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);
+    }
+}
+
+PhysicalDeviceFragmentShadingRateKHR::PhysicalDeviceFragmentShadingRateKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR), pNext(nullptr), sampleCounts(), fragmentSize() {}
+
+PhysicalDeviceFragmentShadingRateKHR::PhysicalDeviceFragmentShadingRateKHR(const PhysicalDeviceFragmentShadingRateKHR& copy_src) {
+    sType = copy_src.sType;
+    sampleCounts = copy_src.sampleCounts;
+    fragmentSize = copy_src.fragmentSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentShadingRateKHR& PhysicalDeviceFragmentShadingRateKHR::operator=(
+    const PhysicalDeviceFragmentShadingRateKHR& 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;
+}
+
+PhysicalDeviceFragmentShadingRateKHR::~PhysicalDeviceFragmentShadingRateKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentShadingRateKHR::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 PhysicalDeviceFragmentShadingRateKHR::initialize(const PhysicalDeviceFragmentShadingRateKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    sampleCounts = copy_src->sampleCounts;
+    fragmentSize = copy_src->fragmentSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR),
+      pNext(nullptr),
+      dynamicRenderingLocalRead() {}
+
+PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(
+    const PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::operator=(
+    const PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& 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;
+}
+
+PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::~PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::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 PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::initialize(
+    const PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dynamicRenderingLocalRead = copy_src->dynamicRenderingLocalRead;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+RenderingAttachmentLocationInfoKHR::RenderingAttachmentLocationInfoKHR(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);
+    }
+}
+
+RenderingAttachmentLocationInfoKHR::RenderingAttachmentLocationInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR),
+      pNext(nullptr),
+      colorAttachmentCount(),
+      pColorAttachmentLocations(nullptr) {}
+
+RenderingAttachmentLocationInfoKHR::RenderingAttachmentLocationInfoKHR(const RenderingAttachmentLocationInfoKHR& 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);
+    }
+}
+
+RenderingAttachmentLocationInfoKHR& RenderingAttachmentLocationInfoKHR::operator=(
+    const RenderingAttachmentLocationInfoKHR& 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;
+}
+
+RenderingAttachmentLocationInfoKHR::~RenderingAttachmentLocationInfoKHR() {
+    if (pColorAttachmentLocations) delete[] pColorAttachmentLocations;
+    FreePnextChain(pNext);
+}
+
+void RenderingAttachmentLocationInfoKHR::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 RenderingAttachmentLocationInfoKHR::initialize(const RenderingAttachmentLocationInfoKHR* 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);
+    }
+}
+
+RenderingInputAttachmentIndexInfoKHR::RenderingInputAttachmentIndexInfoKHR(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);
+    }
+}
+
+RenderingInputAttachmentIndexInfoKHR::RenderingInputAttachmentIndexInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR),
+      pNext(nullptr),
+      colorAttachmentCount(),
+      pColorAttachmentInputIndices(nullptr),
+      pDepthInputAttachmentIndex(nullptr),
+      pStencilInputAttachmentIndex(nullptr) {}
+
+RenderingInputAttachmentIndexInfoKHR::RenderingInputAttachmentIndexInfoKHR(const RenderingInputAttachmentIndexInfoKHR& 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);
+    }
+}
+
+RenderingInputAttachmentIndexInfoKHR& RenderingInputAttachmentIndexInfoKHR::operator=(
+    const RenderingInputAttachmentIndexInfoKHR& 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;
+}
+
+RenderingInputAttachmentIndexInfoKHR::~RenderingInputAttachmentIndexInfoKHR() {
+    if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices;
+    if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex;
+    if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex;
+    FreePnextChain(pNext);
+}
+
+void RenderingInputAttachmentIndexInfoKHR::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 RenderingInputAttachmentIndexInfoKHR::initialize(const RenderingInputAttachmentIndexInfoKHR* 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);
+    }
+}
+
+PhysicalDeviceShaderQuadControlFeaturesKHR::PhysicalDeviceShaderQuadControlFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceShaderQuadControlFeaturesKHR::PhysicalDeviceShaderQuadControlFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR), pNext(nullptr), shaderQuadControl() {}
+
+PhysicalDeviceShaderQuadControlFeaturesKHR::PhysicalDeviceShaderQuadControlFeaturesKHR(
+    const PhysicalDeviceShaderQuadControlFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderQuadControl = copy_src.shaderQuadControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderQuadControlFeaturesKHR& PhysicalDeviceShaderQuadControlFeaturesKHR::operator=(
+    const PhysicalDeviceShaderQuadControlFeaturesKHR& 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;
+}
+
+PhysicalDeviceShaderQuadControlFeaturesKHR::~PhysicalDeviceShaderQuadControlFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderQuadControlFeaturesKHR::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 PhysicalDeviceShaderQuadControlFeaturesKHR::initialize(const PhysicalDeviceShaderQuadControlFeaturesKHR* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderQuadControl = copy_src->shaderQuadControl;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SurfaceProtectedCapabilitiesKHR::SurfaceProtectedCapabilitiesKHR(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);
+    }
+}
+
+SurfaceProtectedCapabilitiesKHR::SurfaceProtectedCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR), pNext(nullptr), supportsProtected() {}
+
+SurfaceProtectedCapabilitiesKHR::SurfaceProtectedCapabilitiesKHR(const SurfaceProtectedCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    supportsProtected = copy_src.supportsProtected;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SurfaceProtectedCapabilitiesKHR& SurfaceProtectedCapabilitiesKHR::operator=(const SurfaceProtectedCapabilitiesKHR& 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;
+}
+
+SurfaceProtectedCapabilitiesKHR::~SurfaceProtectedCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void SurfaceProtectedCapabilitiesKHR::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 SurfaceProtectedCapabilitiesKHR::initialize(const SurfaceProtectedCapabilitiesKHR* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    supportsProtected = copy_src->supportsProtected;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePresentWaitFeaturesKHR::PhysicalDevicePresentWaitFeaturesKHR(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);
+    }
+}
+
+PhysicalDevicePresentWaitFeaturesKHR::PhysicalDevicePresentWaitFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR), pNext(nullptr), presentWait() {}
+
+PhysicalDevicePresentWaitFeaturesKHR::PhysicalDevicePresentWaitFeaturesKHR(const PhysicalDevicePresentWaitFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    presentWait = copy_src.presentWait;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePresentWaitFeaturesKHR& PhysicalDevicePresentWaitFeaturesKHR::operator=(
+    const PhysicalDevicePresentWaitFeaturesKHR& 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;
+}
+
+PhysicalDevicePresentWaitFeaturesKHR::~PhysicalDevicePresentWaitFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDevicePresentWaitFeaturesKHR::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 PhysicalDevicePresentWaitFeaturesKHR::initialize(const PhysicalDevicePresentWaitFeaturesKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentWait = copy_src->presentWait;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR),
+      pNext(nullptr),
+      pipelineExecutableInfo() {}
+
+PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+    const PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    pipelineExecutableInfo = copy_src.pipelineExecutableInfo;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::operator=(
+    const PhysicalDevicePipelineExecutablePropertiesFeaturesKHR& 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;
+}
+
+PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::~PhysicalDevicePipelineExecutablePropertiesFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::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 PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize(
+    const PhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineExecutableInfo = copy_src->pipelineExecutableInfo;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineInfoKHR::PipelineInfoKHR(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);
+    }
+}
+
+PipelineInfoKHR::PipelineInfoKHR() : sType(VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR), pNext(nullptr), pipeline() {}
+
+PipelineInfoKHR::PipelineInfoKHR(const PipelineInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineInfoKHR& PipelineInfoKHR::operator=(const PipelineInfoKHR& 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;
+}
+
+PipelineInfoKHR::~PipelineInfoKHR() { FreePnextChain(pNext); }
+
+void PipelineInfoKHR::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 PipelineInfoKHR::initialize(const PipelineInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipeline = copy_src->pipeline;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineExecutablePropertiesKHR::PipelineExecutablePropertiesKHR(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];
+    }
+}
+
+PipelineExecutablePropertiesKHR::PipelineExecutablePropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR), pNext(nullptr), stages(), subgroupSize() {}
+
+PipelineExecutablePropertiesKHR::PipelineExecutablePropertiesKHR(const PipelineExecutablePropertiesKHR& 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];
+    }
+}
+
+PipelineExecutablePropertiesKHR& PipelineExecutablePropertiesKHR::operator=(const PipelineExecutablePropertiesKHR& 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;
+}
+
+PipelineExecutablePropertiesKHR::~PipelineExecutablePropertiesKHR() { FreePnextChain(pNext); }
+
+void PipelineExecutablePropertiesKHR::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 PipelineExecutablePropertiesKHR::initialize(const PipelineExecutablePropertiesKHR* 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];
+    }
+}
+
+PipelineExecutableInfoKHR::PipelineExecutableInfoKHR(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);
+    }
+}
+
+PipelineExecutableInfoKHR::PipelineExecutableInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR), pNext(nullptr), pipeline(), executableIndex() {}
+
+PipelineExecutableInfoKHR::PipelineExecutableInfoKHR(const PipelineExecutableInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pipeline = copy_src.pipeline;
+    executableIndex = copy_src.executableIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineExecutableInfoKHR& PipelineExecutableInfoKHR::operator=(const PipelineExecutableInfoKHR& 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;
+}
+
+PipelineExecutableInfoKHR::~PipelineExecutableInfoKHR() { FreePnextChain(pNext); }
+
+void PipelineExecutableInfoKHR::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 PipelineExecutableInfoKHR::initialize(const PipelineExecutableInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipeline = copy_src->pipeline;
+    executableIndex = copy_src->executableIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineExecutableStatisticKHR::PipelineExecutableStatisticKHR(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];
+    }
+}
+
+PipelineExecutableStatisticKHR::PipelineExecutableStatisticKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR), pNext(nullptr), format(), value() {}
+
+PipelineExecutableStatisticKHR::PipelineExecutableStatisticKHR(const PipelineExecutableStatisticKHR& 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];
+    }
+}
+
+PipelineExecutableStatisticKHR& PipelineExecutableStatisticKHR::operator=(const PipelineExecutableStatisticKHR& 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;
+}
+
+PipelineExecutableStatisticKHR::~PipelineExecutableStatisticKHR() { FreePnextChain(pNext); }
+
+void PipelineExecutableStatisticKHR::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 PipelineExecutableStatisticKHR::initialize(const PipelineExecutableStatisticKHR* 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];
+    }
+}
+
+PipelineExecutableInternalRepresentationKHR::PipelineExecutableInternalRepresentationKHR(
+    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;
+    }
+}
+
+PipelineExecutableInternalRepresentationKHR::PipelineExecutableInternalRepresentationKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR),
+      pNext(nullptr),
+      isText(),
+      dataSize(),
+      pData(nullptr) {}
+
+PipelineExecutableInternalRepresentationKHR::PipelineExecutableInternalRepresentationKHR(
+    const PipelineExecutableInternalRepresentationKHR& 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;
+    }
+}
+
+PipelineExecutableInternalRepresentationKHR& PipelineExecutableInternalRepresentationKHR::operator=(
+    const PipelineExecutableInternalRepresentationKHR& 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;
+}
+
+PipelineExecutableInternalRepresentationKHR::~PipelineExecutableInternalRepresentationKHR() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+}
+
+void PipelineExecutableInternalRepresentationKHR::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 PipelineExecutableInternalRepresentationKHR::initialize(const PipelineExecutableInternalRepresentationKHR* 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;
+    }
+}
+
+MemoryMapInfoKHR::MemoryMapInfoKHR(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);
+    }
+}
+
+MemoryMapInfoKHR::MemoryMapInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR), pNext(nullptr), flags(), memory(), offset(), size() {}
+
+MemoryMapInfoKHR::MemoryMapInfoKHR(const MemoryMapInfoKHR& 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);
+}
+
+MemoryMapInfoKHR& MemoryMapInfoKHR::operator=(const MemoryMapInfoKHR& 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;
+}
+
+MemoryMapInfoKHR::~MemoryMapInfoKHR() { FreePnextChain(pNext); }
+
+void MemoryMapInfoKHR::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 MemoryMapInfoKHR::initialize(const MemoryMapInfoKHR* 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);
+}
+
+MemoryUnmapInfoKHR::MemoryUnmapInfoKHR(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);
+    }
+}
+
+MemoryUnmapInfoKHR::MemoryUnmapInfoKHR() : sType(VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR), pNext(nullptr), flags(), memory() {}
+
+MemoryUnmapInfoKHR::MemoryUnmapInfoKHR(const MemoryUnmapInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryUnmapInfoKHR& MemoryUnmapInfoKHR::operator=(const MemoryUnmapInfoKHR& 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;
+}
+
+MemoryUnmapInfoKHR::~MemoryUnmapInfoKHR() { FreePnextChain(pNext); }
+
+void MemoryUnmapInfoKHR::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 MemoryUnmapInfoKHR::initialize(const MemoryUnmapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    memory = copy_src->memory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineLibraryCreateInfoKHR::PipelineLibraryCreateInfoKHR(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];
+        }
+    }
+}
+
+PipelineLibraryCreateInfoKHR::PipelineLibraryCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR), pNext(nullptr), libraryCount(), pLibraries(nullptr) {}
+
+PipelineLibraryCreateInfoKHR::PipelineLibraryCreateInfoKHR(const PipelineLibraryCreateInfoKHR& 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];
+        }
+    }
+}
+
+PipelineLibraryCreateInfoKHR& PipelineLibraryCreateInfoKHR::operator=(const PipelineLibraryCreateInfoKHR& 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;
+}
+
+PipelineLibraryCreateInfoKHR::~PipelineLibraryCreateInfoKHR() {
+    if (pLibraries) delete[] pLibraries;
+    FreePnextChain(pNext);
+}
+
+void PipelineLibraryCreateInfoKHR::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 PipelineLibraryCreateInfoKHR::initialize(const PipelineLibraryCreateInfoKHR* 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];
+        }
+    }
+}
+
+PresentIdKHR::PresentIdKHR(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);
+    }
+}
+
+PresentIdKHR::PresentIdKHR() : sType(VK_STRUCTURE_TYPE_PRESENT_ID_KHR), pNext(nullptr), swapchainCount(), pPresentIds(nullptr) {}
+
+PresentIdKHR::PresentIdKHR(const PresentIdKHR& 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);
+    }
+}
+
+PresentIdKHR& PresentIdKHR::operator=(const PresentIdKHR& 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;
+}
+
+PresentIdKHR::~PresentIdKHR() {
+    if (pPresentIds) delete[] pPresentIds;
+    FreePnextChain(pNext);
+}
+
+void PresentIdKHR::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 PresentIdKHR::initialize(const PresentIdKHR* 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);
+    }
+}
+
+PhysicalDevicePresentIdFeaturesKHR::PhysicalDevicePresentIdFeaturesKHR(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);
+    }
+}
+
+PhysicalDevicePresentIdFeaturesKHR::PhysicalDevicePresentIdFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR), pNext(nullptr), presentId() {}
+
+PhysicalDevicePresentIdFeaturesKHR::PhysicalDevicePresentIdFeaturesKHR(const PhysicalDevicePresentIdFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    presentId = copy_src.presentId;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePresentIdFeaturesKHR& PhysicalDevicePresentIdFeaturesKHR::operator=(
+    const PhysicalDevicePresentIdFeaturesKHR& 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;
+}
+
+PhysicalDevicePresentIdFeaturesKHR::~PhysicalDevicePresentIdFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDevicePresentIdFeaturesKHR::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 PhysicalDevicePresentIdFeaturesKHR::initialize(const PhysicalDevicePresentIdFeaturesKHR* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentId = copy_src->presentId;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoEncodeInfoKHR::VideoEncodeInfoKHR(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 VideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot);
+    if (referenceSlotCount && in_struct->pReferenceSlots) {
+        pReferenceSlots = new VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+VideoEncodeInfoKHR::VideoEncodeInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      dstBuffer(),
+      dstBufferOffset(),
+      dstBufferRange(),
+      pSetupReferenceSlot(nullptr),
+      referenceSlotCount(),
+      pReferenceSlots(nullptr),
+      precedingExternallyEncodedBytes() {}
+
+VideoEncodeInfoKHR::VideoEncodeInfoKHR(const VideoEncodeInfoKHR& 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 VideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src.pReferenceSlots) {
+        pReferenceSlots = new VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+}
+
+VideoEncodeInfoKHR& VideoEncodeInfoKHR::operator=(const VideoEncodeInfoKHR& 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 VideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src.pReferenceSlots) {
+        pReferenceSlots = new VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+
+    return *this;
+}
+
+VideoEncodeInfoKHR::~VideoEncodeInfoKHR() {
+    if (pSetupReferenceSlot) delete pSetupReferenceSlot;
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeInfoKHR::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 VideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot);
+    if (referenceSlotCount && in_struct->pReferenceSlots) {
+        pReferenceSlots = new VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+void VideoEncodeInfoKHR::initialize(const VideoEncodeInfoKHR* 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 VideoReferenceSlotInfoKHR(*copy_src->pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src->pReferenceSlots) {
+        pReferenceSlots = new VideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src->pReferenceSlots[i]);
+        }
+    }
+}
+
+VideoEncodeCapabilitiesKHR::VideoEncodeCapabilitiesKHR(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);
+    }
+}
+
+VideoEncodeCapabilitiesKHR::VideoEncodeCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR),
+      pNext(nullptr),
+      flags(),
+      rateControlModes(),
+      maxRateControlLayers(),
+      maxBitrate(),
+      maxQualityLevels(),
+      encodeInputPictureGranularity(),
+      supportedEncodeFeedbackFlags() {}
+
+VideoEncodeCapabilitiesKHR::VideoEncodeCapabilitiesKHR(const VideoEncodeCapabilitiesKHR& 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);
+}
+
+VideoEncodeCapabilitiesKHR& VideoEncodeCapabilitiesKHR::operator=(const VideoEncodeCapabilitiesKHR& 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;
+}
+
+VideoEncodeCapabilitiesKHR::~VideoEncodeCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeCapabilitiesKHR::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 VideoEncodeCapabilitiesKHR::initialize(const VideoEncodeCapabilitiesKHR* 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);
+}
+
+QueryPoolVideoEncodeFeedbackCreateInfoKHR::QueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    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);
+    }
+}
+
+QueryPoolVideoEncodeFeedbackCreateInfoKHR::QueryPoolVideoEncodeFeedbackCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR), pNext(nullptr), encodeFeedbackFlags() {}
+
+QueryPoolVideoEncodeFeedbackCreateInfoKHR::QueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    const QueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    encodeFeedbackFlags = copy_src.encodeFeedbackFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+QueryPoolVideoEncodeFeedbackCreateInfoKHR& QueryPoolVideoEncodeFeedbackCreateInfoKHR::operator=(
+    const QueryPoolVideoEncodeFeedbackCreateInfoKHR& 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;
+}
+
+QueryPoolVideoEncodeFeedbackCreateInfoKHR::~QueryPoolVideoEncodeFeedbackCreateInfoKHR() { FreePnextChain(pNext); }
+
+void QueryPoolVideoEncodeFeedbackCreateInfoKHR::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 QueryPoolVideoEncodeFeedbackCreateInfoKHR::initialize(const QueryPoolVideoEncodeFeedbackCreateInfoKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    encodeFeedbackFlags = copy_src->encodeFeedbackFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoEncodeUsageInfoKHR::VideoEncodeUsageInfoKHR(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);
+    }
+}
+
+VideoEncodeUsageInfoKHR::VideoEncodeUsageInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR), pNext(nullptr), videoUsageHints(), videoContentHints(), tuningMode() {}
+
+VideoEncodeUsageInfoKHR::VideoEncodeUsageInfoKHR(const VideoEncodeUsageInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    videoUsageHints = copy_src.videoUsageHints;
+    videoContentHints = copy_src.videoContentHints;
+    tuningMode = copy_src.tuningMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEncodeUsageInfoKHR& VideoEncodeUsageInfoKHR::operator=(const VideoEncodeUsageInfoKHR& 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;
+}
+
+VideoEncodeUsageInfoKHR::~VideoEncodeUsageInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeUsageInfoKHR::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 VideoEncodeUsageInfoKHR::initialize(const VideoEncodeUsageInfoKHR* 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);
+}
+
+VideoEncodeRateControlLayerInfoKHR::VideoEncodeRateControlLayerInfoKHR(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);
+    }
+}
+
+VideoEncodeRateControlLayerInfoKHR::VideoEncodeRateControlLayerInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR),
+      pNext(nullptr),
+      averageBitrate(),
+      maxBitrate(),
+      frameRateNumerator(),
+      frameRateDenominator() {}
+
+VideoEncodeRateControlLayerInfoKHR::VideoEncodeRateControlLayerInfoKHR(const VideoEncodeRateControlLayerInfoKHR& 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);
+}
+
+VideoEncodeRateControlLayerInfoKHR& VideoEncodeRateControlLayerInfoKHR::operator=(
+    const VideoEncodeRateControlLayerInfoKHR& 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;
+}
+
+VideoEncodeRateControlLayerInfoKHR::~VideoEncodeRateControlLayerInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeRateControlLayerInfoKHR::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 VideoEncodeRateControlLayerInfoKHR::initialize(const VideoEncodeRateControlLayerInfoKHR* 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);
+}
+
+VideoEncodeRateControlInfoKHR::VideoEncodeRateControlInfoKHR(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 VideoEncodeRateControlLayerInfoKHR[layerCount];
+        for (uint32_t i = 0; i < layerCount; ++i) {
+            pLayers[i].initialize(&in_struct->pLayers[i]);
+        }
+    }
+}
+
+VideoEncodeRateControlInfoKHR::VideoEncodeRateControlInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      rateControlMode(),
+      layerCount(),
+      pLayers(nullptr),
+      virtualBufferSizeInMs(),
+      initialVirtualBufferSizeInMs() {}
+
+VideoEncodeRateControlInfoKHR::VideoEncodeRateControlInfoKHR(const VideoEncodeRateControlInfoKHR& 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 VideoEncodeRateControlLayerInfoKHR[layerCount];
+        for (uint32_t i = 0; i < layerCount; ++i) {
+            pLayers[i].initialize(&copy_src.pLayers[i]);
+        }
+    }
+}
+
+VideoEncodeRateControlInfoKHR& VideoEncodeRateControlInfoKHR::operator=(const VideoEncodeRateControlInfoKHR& 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 VideoEncodeRateControlLayerInfoKHR[layerCount];
+        for (uint32_t i = 0; i < layerCount; ++i) {
+            pLayers[i].initialize(&copy_src.pLayers[i]);
+        }
+    }
+
+    return *this;
+}
+
+VideoEncodeRateControlInfoKHR::~VideoEncodeRateControlInfoKHR() {
+    if (pLayers) delete[] pLayers;
+    FreePnextChain(pNext);
+}
+
+void VideoEncodeRateControlInfoKHR::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 VideoEncodeRateControlLayerInfoKHR[layerCount];
+        for (uint32_t i = 0; i < layerCount; ++i) {
+            pLayers[i].initialize(&in_struct->pLayers[i]);
+        }
+    }
+}
+
+void VideoEncodeRateControlInfoKHR::initialize(const VideoEncodeRateControlInfoKHR* 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 VideoEncodeRateControlLayerInfoKHR[layerCount];
+        for (uint32_t i = 0; i < layerCount; ++i) {
+            pLayers[i].initialize(&copy_src->pLayers[i]);
+        }
+    }
+}
+
+PhysicalDeviceVideoEncodeQualityLevelInfoKHR::PhysicalDeviceVideoEncodeQualityLevelInfoKHR(
+    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 VideoProfileInfoKHR(in_struct->pVideoProfile);
+}
+
+PhysicalDeviceVideoEncodeQualityLevelInfoKHR::PhysicalDeviceVideoEncodeQualityLevelInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR),
+      pNext(nullptr),
+      pVideoProfile(nullptr),
+      qualityLevel() {}
+
+PhysicalDeviceVideoEncodeQualityLevelInfoKHR::PhysicalDeviceVideoEncodeQualityLevelInfoKHR(
+    const PhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pVideoProfile = nullptr;
+    qualityLevel = copy_src.qualityLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pVideoProfile) pVideoProfile = new VideoProfileInfoKHR(*copy_src.pVideoProfile);
+}
+
+PhysicalDeviceVideoEncodeQualityLevelInfoKHR& PhysicalDeviceVideoEncodeQualityLevelInfoKHR::operator=(
+    const PhysicalDeviceVideoEncodeQualityLevelInfoKHR& 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 VideoProfileInfoKHR(*copy_src.pVideoProfile);
+
+    return *this;
+}
+
+PhysicalDeviceVideoEncodeQualityLevelInfoKHR::~PhysicalDeviceVideoEncodeQualityLevelInfoKHR() {
+    if (pVideoProfile) delete pVideoProfile;
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceVideoEncodeQualityLevelInfoKHR::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 VideoProfileInfoKHR(in_struct->pVideoProfile);
+}
+
+void PhysicalDeviceVideoEncodeQualityLevelInfoKHR::initialize(const PhysicalDeviceVideoEncodeQualityLevelInfoKHR* 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 VideoProfileInfoKHR(*copy_src->pVideoProfile);
+}
+
+VideoEncodeQualityLevelPropertiesKHR::VideoEncodeQualityLevelPropertiesKHR(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);
+    }
+}
+
+VideoEncodeQualityLevelPropertiesKHR::VideoEncodeQualityLevelPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR),
+      pNext(nullptr),
+      preferredRateControlMode(),
+      preferredRateControlLayerCount() {}
+
+VideoEncodeQualityLevelPropertiesKHR::VideoEncodeQualityLevelPropertiesKHR(const VideoEncodeQualityLevelPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    preferredRateControlMode = copy_src.preferredRateControlMode;
+    preferredRateControlLayerCount = copy_src.preferredRateControlLayerCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEncodeQualityLevelPropertiesKHR& VideoEncodeQualityLevelPropertiesKHR::operator=(
+    const VideoEncodeQualityLevelPropertiesKHR& 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;
+}
+
+VideoEncodeQualityLevelPropertiesKHR::~VideoEncodeQualityLevelPropertiesKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeQualityLevelPropertiesKHR::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 VideoEncodeQualityLevelPropertiesKHR::initialize(const VideoEncodeQualityLevelPropertiesKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    preferredRateControlMode = copy_src->preferredRateControlMode;
+    preferredRateControlLayerCount = copy_src->preferredRateControlLayerCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoEncodeQualityLevelInfoKHR::VideoEncodeQualityLevelInfoKHR(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);
+    }
+}
+
+VideoEncodeQualityLevelInfoKHR::VideoEncodeQualityLevelInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR), pNext(nullptr), qualityLevel() {}
+
+VideoEncodeQualityLevelInfoKHR::VideoEncodeQualityLevelInfoKHR(const VideoEncodeQualityLevelInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    qualityLevel = copy_src.qualityLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEncodeQualityLevelInfoKHR& VideoEncodeQualityLevelInfoKHR::operator=(const VideoEncodeQualityLevelInfoKHR& 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;
+}
+
+VideoEncodeQualityLevelInfoKHR::~VideoEncodeQualityLevelInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeQualityLevelInfoKHR::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 VideoEncodeQualityLevelInfoKHR::initialize(const VideoEncodeQualityLevelInfoKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    qualityLevel = copy_src->qualityLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoEncodeSessionParametersGetInfoKHR::VideoEncodeSessionParametersGetInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeSessionParametersGetInfoKHR::VideoEncodeSessionParametersGetInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR), pNext(nullptr), videoSessionParameters() {}
+
+VideoEncodeSessionParametersGetInfoKHR::VideoEncodeSessionParametersGetInfoKHR(
+    const VideoEncodeSessionParametersGetInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    videoSessionParameters = copy_src.videoSessionParameters;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEncodeSessionParametersGetInfoKHR& VideoEncodeSessionParametersGetInfoKHR::operator=(
+    const VideoEncodeSessionParametersGetInfoKHR& 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;
+}
+
+VideoEncodeSessionParametersGetInfoKHR::~VideoEncodeSessionParametersGetInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeSessionParametersGetInfoKHR::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 VideoEncodeSessionParametersGetInfoKHR::initialize(const VideoEncodeSessionParametersGetInfoKHR* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoSessionParameters = copy_src->videoSessionParameters;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoEncodeSessionParametersFeedbackInfoKHR::VideoEncodeSessionParametersFeedbackInfoKHR(
+    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);
+    }
+}
+
+VideoEncodeSessionParametersFeedbackInfoKHR::VideoEncodeSessionParametersFeedbackInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR), pNext(nullptr), hasOverrides() {}
+
+VideoEncodeSessionParametersFeedbackInfoKHR::VideoEncodeSessionParametersFeedbackInfoKHR(
+    const VideoEncodeSessionParametersFeedbackInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    hasOverrides = copy_src.hasOverrides;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoEncodeSessionParametersFeedbackInfoKHR& VideoEncodeSessionParametersFeedbackInfoKHR::operator=(
+    const VideoEncodeSessionParametersFeedbackInfoKHR& 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;
+}
+
+VideoEncodeSessionParametersFeedbackInfoKHR::~VideoEncodeSessionParametersFeedbackInfoKHR() { FreePnextChain(pNext); }
+
+void VideoEncodeSessionParametersFeedbackInfoKHR::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 VideoEncodeSessionParametersFeedbackInfoKHR::initialize(const VideoEncodeSessionParametersFeedbackInfoKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hasOverrides = copy_src->hasOverrides;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceFragmentShaderBarycentricFeaturesKHR::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentShaderBarycentricFeaturesKHR::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR),
+      pNext(nullptr),
+      fragmentShaderBarycentric() {}
+
+PhysicalDeviceFragmentShaderBarycentricFeaturesKHR::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    const PhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    fragmentShaderBarycentric = copy_src.fragmentShaderBarycentric;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentShaderBarycentricFeaturesKHR& PhysicalDeviceFragmentShaderBarycentricFeaturesKHR::operator=(
+    const PhysicalDeviceFragmentShaderBarycentricFeaturesKHR& 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;
+}
+
+PhysicalDeviceFragmentShaderBarycentricFeaturesKHR::~PhysicalDeviceFragmentShaderBarycentricFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentShaderBarycentricFeaturesKHR::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 PhysicalDeviceFragmentShaderBarycentricFeaturesKHR::initialize(
+    const PhysicalDeviceFragmentShaderBarycentricFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentShaderBarycentric = copy_src->fragmentShaderBarycentric;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceFragmentShaderBarycentricPropertiesKHR::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentShaderBarycentricPropertiesKHR::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR),
+      pNext(nullptr),
+      triStripVertexOrderIndependentOfProvokingVertex() {}
+
+PhysicalDeviceFragmentShaderBarycentricPropertiesKHR::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    const PhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    triStripVertexOrderIndependentOfProvokingVertex = copy_src.triStripVertexOrderIndependentOfProvokingVertex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentShaderBarycentricPropertiesKHR& PhysicalDeviceFragmentShaderBarycentricPropertiesKHR::operator=(
+    const PhysicalDeviceFragmentShaderBarycentricPropertiesKHR& 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;
+}
+
+PhysicalDeviceFragmentShaderBarycentricPropertiesKHR::~PhysicalDeviceFragmentShaderBarycentricPropertiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceFragmentShaderBarycentricPropertiesKHR::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 PhysicalDeviceFragmentShaderBarycentricPropertiesKHR::initialize(
+    const PhysicalDeviceFragmentShaderBarycentricPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    triStripVertexOrderIndependentOfProvokingVertex = copy_src->triStripVertexOrderIndependentOfProvokingVertex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR),
+      pNext(nullptr),
+      shaderSubgroupUniformControlFlow() {}
+
+PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+    const PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderSubgroupUniformControlFlow = copy_src.shaderSubgroupUniformControlFlow;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::operator=(
+    const PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& 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;
+}
+
+PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::~PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::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 PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::initialize(
+    const PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSubgroupUniformControlFlow = copy_src->shaderSubgroupUniformControlFlow;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR),
+      pNext(nullptr),
+      workgroupMemoryExplicitLayout(),
+      workgroupMemoryExplicitLayoutScalarBlockLayout(),
+      workgroupMemoryExplicitLayout8BitAccess(),
+      workgroupMemoryExplicitLayout16BitAccess() {}
+
+PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+    const PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& 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);
+}
+
+PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::operator=(
+    const PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& 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;
+}
+
+PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::~PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::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 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize(
+    const PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* 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);
+}
+
+PhysicalDeviceRayTracingMaintenance1FeaturesKHR::PhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceRayTracingMaintenance1FeaturesKHR::PhysicalDeviceRayTracingMaintenance1FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR),
+      pNext(nullptr),
+      rayTracingMaintenance1(),
+      rayTracingPipelineTraceRaysIndirect2() {}
+
+PhysicalDeviceRayTracingMaintenance1FeaturesKHR::PhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    const PhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    rayTracingMaintenance1 = copy_src.rayTracingMaintenance1;
+    rayTracingPipelineTraceRaysIndirect2 = copy_src.rayTracingPipelineTraceRaysIndirect2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRayTracingMaintenance1FeaturesKHR& PhysicalDeviceRayTracingMaintenance1FeaturesKHR::operator=(
+    const PhysicalDeviceRayTracingMaintenance1FeaturesKHR& 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;
+}
+
+PhysicalDeviceRayTracingMaintenance1FeaturesKHR::~PhysicalDeviceRayTracingMaintenance1FeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRayTracingMaintenance1FeaturesKHR::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 PhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize(const PhysicalDeviceRayTracingMaintenance1FeaturesKHR* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingMaintenance1 = copy_src->rayTracingMaintenance1;
+    rayTracingPipelineTraceRaysIndirect2 = copy_src->rayTracingPipelineTraceRaysIndirect2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderSubgroupRotateFeaturesKHR::PhysicalDeviceShaderSubgroupRotateFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceShaderSubgroupRotateFeaturesKHR::PhysicalDeviceShaderSubgroupRotateFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR),
+      pNext(nullptr),
+      shaderSubgroupRotate(),
+      shaderSubgroupRotateClustered() {}
+
+PhysicalDeviceShaderSubgroupRotateFeaturesKHR::PhysicalDeviceShaderSubgroupRotateFeaturesKHR(
+    const PhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderSubgroupRotate = copy_src.shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderSubgroupRotateFeaturesKHR& PhysicalDeviceShaderSubgroupRotateFeaturesKHR::operator=(
+    const PhysicalDeviceShaderSubgroupRotateFeaturesKHR& 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;
+}
+
+PhysicalDeviceShaderSubgroupRotateFeaturesKHR::~PhysicalDeviceShaderSubgroupRotateFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderSubgroupRotateFeaturesKHR::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 PhysicalDeviceShaderSubgroupRotateFeaturesKHR::initialize(const PhysicalDeviceShaderSubgroupRotateFeaturesKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSubgroupRotate = copy_src->shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = copy_src->shaderSubgroupRotateClustered;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR),
+      pNext(nullptr),
+      shaderMaximalReconvergence() {}
+
+PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(
+    const PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderMaximalReconvergence = copy_src.shaderMaximalReconvergence;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::operator=(
+    const PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& 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;
+}
+
+PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::~PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::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 PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize(
+    const PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderMaximalReconvergence = copy_src->shaderMaximalReconvergence;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMaintenance5FeaturesKHR::PhysicalDeviceMaintenance5FeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceMaintenance5FeaturesKHR::PhysicalDeviceMaintenance5FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR), pNext(nullptr), maintenance5() {}
+
+PhysicalDeviceMaintenance5FeaturesKHR::PhysicalDeviceMaintenance5FeaturesKHR(
+    const PhysicalDeviceMaintenance5FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    maintenance5 = copy_src.maintenance5;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMaintenance5FeaturesKHR& PhysicalDeviceMaintenance5FeaturesKHR::operator=(
+    const PhysicalDeviceMaintenance5FeaturesKHR& 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;
+}
+
+PhysicalDeviceMaintenance5FeaturesKHR::~PhysicalDeviceMaintenance5FeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMaintenance5FeaturesKHR::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 PhysicalDeviceMaintenance5FeaturesKHR::initialize(const PhysicalDeviceMaintenance5FeaturesKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maintenance5 = copy_src->maintenance5;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMaintenance5PropertiesKHR::PhysicalDeviceMaintenance5PropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceMaintenance5PropertiesKHR::PhysicalDeviceMaintenance5PropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR),
+      pNext(nullptr),
+      earlyFragmentMultisampleCoverageAfterSampleCounting(),
+      earlyFragmentSampleMaskTestBeforeSampleCounting(),
+      depthStencilSwizzleOneSupport(),
+      polygonModePointSize(),
+      nonStrictSinglePixelWideLinesUseParallelogram(),
+      nonStrictWideLinesUseParallelogram() {}
+
+PhysicalDeviceMaintenance5PropertiesKHR::PhysicalDeviceMaintenance5PropertiesKHR(
+    const PhysicalDeviceMaintenance5PropertiesKHR& 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);
+}
+
+PhysicalDeviceMaintenance5PropertiesKHR& PhysicalDeviceMaintenance5PropertiesKHR::operator=(
+    const PhysicalDeviceMaintenance5PropertiesKHR& 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;
+}
+
+PhysicalDeviceMaintenance5PropertiesKHR::~PhysicalDeviceMaintenance5PropertiesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMaintenance5PropertiesKHR::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 PhysicalDeviceMaintenance5PropertiesKHR::initialize(const PhysicalDeviceMaintenance5PropertiesKHR* 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);
+}
+
+RenderingAreaInfoKHR::RenderingAreaInfoKHR(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);
+    }
+}
+
+RenderingAreaInfoKHR::RenderingAreaInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR),
+      pNext(nullptr),
+      viewMask(),
+      colorAttachmentCount(),
+      pColorAttachmentFormats(nullptr),
+      depthAttachmentFormat(),
+      stencilAttachmentFormat() {}
+
+RenderingAreaInfoKHR::RenderingAreaInfoKHR(const RenderingAreaInfoKHR& 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);
+    }
+}
+
+RenderingAreaInfoKHR& RenderingAreaInfoKHR::operator=(const RenderingAreaInfoKHR& 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;
+}
+
+RenderingAreaInfoKHR::~RenderingAreaInfoKHR() {
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+}
+
+void RenderingAreaInfoKHR::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 RenderingAreaInfoKHR::initialize(const RenderingAreaInfoKHR* 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);
+    }
+}
+
+ImageSubresource2KHR::ImageSubresource2KHR(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);
+    }
+}
+
+ImageSubresource2KHR::ImageSubresource2KHR()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR), pNext(nullptr), imageSubresource() {}
+
+ImageSubresource2KHR::ImageSubresource2KHR(const ImageSubresource2KHR& copy_src) {
+    sType = copy_src.sType;
+    imageSubresource = copy_src.imageSubresource;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageSubresource2KHR& ImageSubresource2KHR::operator=(const ImageSubresource2KHR& 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;
+}
+
+ImageSubresource2KHR::~ImageSubresource2KHR() { FreePnextChain(pNext); }
+
+void ImageSubresource2KHR::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 ImageSubresource2KHR::initialize(const ImageSubresource2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageSubresource = copy_src->imageSubresource;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DeviceImageSubresourceInfoKHR::DeviceImageSubresourceInfoKHR(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 ImageCreateInfo(in_struct->pCreateInfo);
+    if (in_struct->pSubresource) pSubresource = new ImageSubresource2KHR(in_struct->pSubresource);
+}
+
+DeviceImageSubresourceInfoKHR::DeviceImageSubresourceInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR), pNext(nullptr), pCreateInfo(nullptr), pSubresource(nullptr) {}
+
+DeviceImageSubresourceInfoKHR::DeviceImageSubresourceInfoKHR(const DeviceImageSubresourceInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    pSubresource = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new ImageCreateInfo(*copy_src.pCreateInfo);
+    if (copy_src.pSubresource) pSubresource = new ImageSubresource2KHR(*copy_src.pSubresource);
+}
+
+DeviceImageSubresourceInfoKHR& DeviceImageSubresourceInfoKHR::operator=(const DeviceImageSubresourceInfoKHR& 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 ImageCreateInfo(*copy_src.pCreateInfo);
+    if (copy_src.pSubresource) pSubresource = new ImageSubresource2KHR(*copy_src.pSubresource);
+
+    return *this;
+}
+
+DeviceImageSubresourceInfoKHR::~DeviceImageSubresourceInfoKHR() {
+    if (pCreateInfo) delete pCreateInfo;
+    if (pSubresource) delete pSubresource;
+    FreePnextChain(pNext);
+}
+
+void DeviceImageSubresourceInfoKHR::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 ImageCreateInfo(in_struct->pCreateInfo);
+    if (in_struct->pSubresource) pSubresource = new ImageSubresource2KHR(in_struct->pSubresource);
+}
+
+void DeviceImageSubresourceInfoKHR::initialize(const DeviceImageSubresourceInfoKHR* 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 ImageCreateInfo(*copy_src->pCreateInfo);
+    if (copy_src->pSubresource) pSubresource = new ImageSubresource2KHR(*copy_src->pSubresource);
+}
+
+SubresourceLayout2KHR::SubresourceLayout2KHR(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);
+    }
+}
+
+SubresourceLayout2KHR::SubresourceLayout2KHR()
+    : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR), pNext(nullptr), subresourceLayout() {}
+
+SubresourceLayout2KHR::SubresourceLayout2KHR(const SubresourceLayout2KHR& copy_src) {
+    sType = copy_src.sType;
+    subresourceLayout = copy_src.subresourceLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SubresourceLayout2KHR& SubresourceLayout2KHR::operator=(const SubresourceLayout2KHR& 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;
+}
+
+SubresourceLayout2KHR::~SubresourceLayout2KHR() { FreePnextChain(pNext); }
+
+void SubresourceLayout2KHR::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 SubresourceLayout2KHR::initialize(const SubresourceLayout2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subresourceLayout = copy_src->subresourceLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineCreateFlags2CreateInfoKHR::PipelineCreateFlags2CreateInfoKHR(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);
+    }
+}
+
+PipelineCreateFlags2CreateInfoKHR::PipelineCreateFlags2CreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), flags() {}
+
+PipelineCreateFlags2CreateInfoKHR::PipelineCreateFlags2CreateInfoKHR(const PipelineCreateFlags2CreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineCreateFlags2CreateInfoKHR& PipelineCreateFlags2CreateInfoKHR::operator=(const PipelineCreateFlags2CreateInfoKHR& 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;
+}
+
+PipelineCreateFlags2CreateInfoKHR::~PipelineCreateFlags2CreateInfoKHR() { FreePnextChain(pNext); }
+
+void PipelineCreateFlags2CreateInfoKHR::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 PipelineCreateFlags2CreateInfoKHR::initialize(const PipelineCreateFlags2CreateInfoKHR* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BufferUsageFlags2CreateInfoKHR::BufferUsageFlags2CreateInfoKHR(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);
+    }
+}
+
+BufferUsageFlags2CreateInfoKHR::BufferUsageFlags2CreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), usage() {}
+
+BufferUsageFlags2CreateInfoKHR::BufferUsageFlags2CreateInfoKHR(const BufferUsageFlags2CreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BufferUsageFlags2CreateInfoKHR& BufferUsageFlags2CreateInfoKHR::operator=(const BufferUsageFlags2CreateInfoKHR& 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;
+}
+
+BufferUsageFlags2CreateInfoKHR::~BufferUsageFlags2CreateInfoKHR() { FreePnextChain(pNext); }
+
+void BufferUsageFlags2CreateInfoKHR::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 BufferUsageFlags2CreateInfoKHR::initialize(const BufferUsageFlags2CreateInfoKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    usage = copy_src->usage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceRayTracingPositionFetchFeaturesKHR::PhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceRayTracingPositionFetchFeaturesKHR::PhysicalDeviceRayTracingPositionFetchFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR), pNext(nullptr), rayTracingPositionFetch() {}
+
+PhysicalDeviceRayTracingPositionFetchFeaturesKHR::PhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    const PhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    rayTracingPositionFetch = copy_src.rayTracingPositionFetch;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRayTracingPositionFetchFeaturesKHR& PhysicalDeviceRayTracingPositionFetchFeaturesKHR::operator=(
+    const PhysicalDeviceRayTracingPositionFetchFeaturesKHR& 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;
+}
+
+PhysicalDeviceRayTracingPositionFetchFeaturesKHR::~PhysicalDeviceRayTracingPositionFetchFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRayTracingPositionFetchFeaturesKHR::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 PhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize(const PhysicalDeviceRayTracingPositionFetchFeaturesKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingPositionFetch = copy_src->rayTracingPositionFetch;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CooperativeMatrixPropertiesKHR::CooperativeMatrixPropertiesKHR(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);
+    }
+}
+
+CooperativeMatrixPropertiesKHR::CooperativeMatrixPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR),
+      pNext(nullptr),
+      MSize(),
+      NSize(),
+      KSize(),
+      AType(),
+      BType(),
+      CType(),
+      ResultType(),
+      saturatingAccumulation(),
+      scope() {}
+
+CooperativeMatrixPropertiesKHR::CooperativeMatrixPropertiesKHR(const CooperativeMatrixPropertiesKHR& 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);
+}
+
+CooperativeMatrixPropertiesKHR& CooperativeMatrixPropertiesKHR::operator=(const CooperativeMatrixPropertiesKHR& 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;
+}
+
+CooperativeMatrixPropertiesKHR::~CooperativeMatrixPropertiesKHR() { FreePnextChain(pNext); }
+
+void CooperativeMatrixPropertiesKHR::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 CooperativeMatrixPropertiesKHR::initialize(const CooperativeMatrixPropertiesKHR* 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);
+}
+
+PhysicalDeviceCooperativeMatrixFeaturesKHR::PhysicalDeviceCooperativeMatrixFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceCooperativeMatrixFeaturesKHR::PhysicalDeviceCooperativeMatrixFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR),
+      pNext(nullptr),
+      cooperativeMatrix(),
+      cooperativeMatrixRobustBufferAccess() {}
+
+PhysicalDeviceCooperativeMatrixFeaturesKHR::PhysicalDeviceCooperativeMatrixFeaturesKHR(
+    const PhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    cooperativeMatrix = copy_src.cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCooperativeMatrixFeaturesKHR& PhysicalDeviceCooperativeMatrixFeaturesKHR::operator=(
+    const PhysicalDeviceCooperativeMatrixFeaturesKHR& 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;
+}
+
+PhysicalDeviceCooperativeMatrixFeaturesKHR::~PhysicalDeviceCooperativeMatrixFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCooperativeMatrixFeaturesKHR::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 PhysicalDeviceCooperativeMatrixFeaturesKHR::initialize(const PhysicalDeviceCooperativeMatrixFeaturesKHR* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeMatrix = copy_src->cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = copy_src->cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceCooperativeMatrixPropertiesKHR::PhysicalDeviceCooperativeMatrixPropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceCooperativeMatrixPropertiesKHR::PhysicalDeviceCooperativeMatrixPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR),
+      pNext(nullptr),
+      cooperativeMatrixSupportedStages() {}
+
+PhysicalDeviceCooperativeMatrixPropertiesKHR::PhysicalDeviceCooperativeMatrixPropertiesKHR(
+    const PhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCooperativeMatrixPropertiesKHR& PhysicalDeviceCooperativeMatrixPropertiesKHR::operator=(
+    const PhysicalDeviceCooperativeMatrixPropertiesKHR& 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;
+}
+
+PhysicalDeviceCooperativeMatrixPropertiesKHR::~PhysicalDeviceCooperativeMatrixPropertiesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCooperativeMatrixPropertiesKHR::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 PhysicalDeviceCooperativeMatrixPropertiesKHR::initialize(const PhysicalDeviceCooperativeMatrixPropertiesKHR* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeMatrixSupportedStages = copy_src->cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoDecodeAV1ProfileInfoKHR::VideoDecodeAV1ProfileInfoKHR(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);
+    }
+}
+
+VideoDecodeAV1ProfileInfoKHR::VideoDecodeAV1ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR), pNext(nullptr), stdProfile(), filmGrainSupport() {}
+
+VideoDecodeAV1ProfileInfoKHR::VideoDecodeAV1ProfileInfoKHR(const VideoDecodeAV1ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfile = copy_src.stdProfile;
+    filmGrainSupport = copy_src.filmGrainSupport;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoDecodeAV1ProfileInfoKHR& VideoDecodeAV1ProfileInfoKHR::operator=(const VideoDecodeAV1ProfileInfoKHR& 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;
+}
+
+VideoDecodeAV1ProfileInfoKHR::~VideoDecodeAV1ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void VideoDecodeAV1ProfileInfoKHR::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 VideoDecodeAV1ProfileInfoKHR::initialize(const VideoDecodeAV1ProfileInfoKHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfile = copy_src->stdProfile;
+    filmGrainSupport = copy_src->filmGrainSupport;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoDecodeAV1CapabilitiesKHR::VideoDecodeAV1CapabilitiesKHR(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);
+    }
+}
+
+VideoDecodeAV1CapabilitiesKHR::VideoDecodeAV1CapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR), pNext(nullptr), maxLevel() {}
+
+VideoDecodeAV1CapabilitiesKHR::VideoDecodeAV1CapabilitiesKHR(const VideoDecodeAV1CapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxLevel = copy_src.maxLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoDecodeAV1CapabilitiesKHR& VideoDecodeAV1CapabilitiesKHR::operator=(const VideoDecodeAV1CapabilitiesKHR& 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;
+}
+
+VideoDecodeAV1CapabilitiesKHR::~VideoDecodeAV1CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void VideoDecodeAV1CapabilitiesKHR::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 VideoDecodeAV1CapabilitiesKHR::initialize(const VideoDecodeAV1CapabilitiesKHR* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxLevel = copy_src->maxLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoDecodeAV1SessionParametersCreateInfoKHR::VideoDecodeAV1SessionParametersCreateInfoKHR(
+    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);
+    }
+}
+
+VideoDecodeAV1SessionParametersCreateInfoKHR::VideoDecodeAV1SessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR), pNext(nullptr), pStdSequenceHeader(nullptr) {}
+
+VideoDecodeAV1SessionParametersCreateInfoKHR::VideoDecodeAV1SessionParametersCreateInfoKHR(
+    const VideoDecodeAV1SessionParametersCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdSequenceHeader = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader);
+    }
+}
+
+VideoDecodeAV1SessionParametersCreateInfoKHR& VideoDecodeAV1SessionParametersCreateInfoKHR::operator=(
+    const VideoDecodeAV1SessionParametersCreateInfoKHR& 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;
+}
+
+VideoDecodeAV1SessionParametersCreateInfoKHR::~VideoDecodeAV1SessionParametersCreateInfoKHR() {
+    if (pStdSequenceHeader) delete pStdSequenceHeader;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeAV1SessionParametersCreateInfoKHR::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 VideoDecodeAV1SessionParametersCreateInfoKHR::initialize(const VideoDecodeAV1SessionParametersCreateInfoKHR* 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);
+    }
+}
+
+VideoDecodeAV1PictureInfoKHR::VideoDecodeAV1PictureInfoKHR(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);
+    }
+}
+
+VideoDecodeAV1PictureInfoKHR::VideoDecodeAV1PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      pStdPictureInfo(nullptr),
+      frameHeaderOffset(),
+      tileCount(),
+      pTileOffsets(nullptr),
+      pTileSizes(nullptr) {}
+
+VideoDecodeAV1PictureInfoKHR::VideoDecodeAV1PictureInfoKHR(const VideoDecodeAV1PictureInfoKHR& 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);
+    }
+}
+
+VideoDecodeAV1PictureInfoKHR& VideoDecodeAV1PictureInfoKHR::operator=(const VideoDecodeAV1PictureInfoKHR& 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;
+}
+
+VideoDecodeAV1PictureInfoKHR::~VideoDecodeAV1PictureInfoKHR() {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pTileOffsets) delete[] pTileOffsets;
+    if (pTileSizes) delete[] pTileSizes;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeAV1PictureInfoKHR::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 VideoDecodeAV1PictureInfoKHR::initialize(const VideoDecodeAV1PictureInfoKHR* 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);
+    }
+}
+
+VideoDecodeAV1DpbSlotInfoKHR::VideoDecodeAV1DpbSlotInfoKHR(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);
+    }
+}
+
+VideoDecodeAV1DpbSlotInfoKHR::VideoDecodeAV1DpbSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {}
+
+VideoDecodeAV1DpbSlotInfoKHR::VideoDecodeAV1DpbSlotInfoKHR(const VideoDecodeAV1DpbSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+}
+
+VideoDecodeAV1DpbSlotInfoKHR& VideoDecodeAV1DpbSlotInfoKHR::operator=(const VideoDecodeAV1DpbSlotInfoKHR& 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;
+}
+
+VideoDecodeAV1DpbSlotInfoKHR::~VideoDecodeAV1DpbSlotInfoKHR() {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+}
+
+void VideoDecodeAV1DpbSlotInfoKHR::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 VideoDecodeAV1DpbSlotInfoKHR::initialize(const VideoDecodeAV1DpbSlotInfoKHR* 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);
+    }
+}
+
+PhysicalDeviceVideoMaintenance1FeaturesKHR::PhysicalDeviceVideoMaintenance1FeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceVideoMaintenance1FeaturesKHR::PhysicalDeviceVideoMaintenance1FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR), pNext(nullptr), videoMaintenance1() {}
+
+PhysicalDeviceVideoMaintenance1FeaturesKHR::PhysicalDeviceVideoMaintenance1FeaturesKHR(
+    const PhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    videoMaintenance1 = copy_src.videoMaintenance1;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceVideoMaintenance1FeaturesKHR& PhysicalDeviceVideoMaintenance1FeaturesKHR::operator=(
+    const PhysicalDeviceVideoMaintenance1FeaturesKHR& 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;
+}
+
+PhysicalDeviceVideoMaintenance1FeaturesKHR::~PhysicalDeviceVideoMaintenance1FeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVideoMaintenance1FeaturesKHR::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 PhysicalDeviceVideoMaintenance1FeaturesKHR::initialize(const PhysicalDeviceVideoMaintenance1FeaturesKHR* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoMaintenance1 = copy_src->videoMaintenance1;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+VideoInlineQueryInfoKHR::VideoInlineQueryInfoKHR(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);
+    }
+}
+
+VideoInlineQueryInfoKHR::VideoInlineQueryInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR), pNext(nullptr), queryPool(), firstQuery(), queryCount() {}
+
+VideoInlineQueryInfoKHR::VideoInlineQueryInfoKHR(const VideoInlineQueryInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    queryPool = copy_src.queryPool;
+    firstQuery = copy_src.firstQuery;
+    queryCount = copy_src.queryCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+VideoInlineQueryInfoKHR& VideoInlineQueryInfoKHR::operator=(const VideoInlineQueryInfoKHR& 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;
+}
+
+VideoInlineQueryInfoKHR::~VideoInlineQueryInfoKHR() { FreePnextChain(pNext); }
+
+void VideoInlineQueryInfoKHR::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 VideoInlineQueryInfoKHR::initialize(const VideoInlineQueryInfoKHR* 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);
+}
+
+PhysicalDeviceVertexAttributeDivisorPropertiesKHR::PhysicalDeviceVertexAttributeDivisorPropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceVertexAttributeDivisorPropertiesKHR::PhysicalDeviceVertexAttributeDivisorPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR),
+      pNext(nullptr),
+      maxVertexAttribDivisor(),
+      supportsNonZeroFirstInstance() {}
+
+PhysicalDeviceVertexAttributeDivisorPropertiesKHR::PhysicalDeviceVertexAttributeDivisorPropertiesKHR(
+    const PhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceVertexAttributeDivisorPropertiesKHR& PhysicalDeviceVertexAttributeDivisorPropertiesKHR::operator=(
+    const PhysicalDeviceVertexAttributeDivisorPropertiesKHR& 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;
+}
+
+PhysicalDeviceVertexAttributeDivisorPropertiesKHR::~PhysicalDeviceVertexAttributeDivisorPropertiesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVertexAttributeDivisorPropertiesKHR::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 PhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize(
+    const PhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = copy_src->supportsNonZeroFirstInstance;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineVertexInputDivisorStateCreateInfoKHR::PipelineVertexInputDivisorStateCreateInfoKHR(
+    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);
+    }
+}
+
+PipelineVertexInputDivisorStateCreateInfoKHR::PipelineVertexInputDivisorStateCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      vertexBindingDivisorCount(),
+      pVertexBindingDivisors(nullptr) {}
+
+PipelineVertexInputDivisorStateCreateInfoKHR::PipelineVertexInputDivisorStateCreateInfoKHR(
+    const PipelineVertexInputDivisorStateCreateInfoKHR& 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);
+    }
+}
+
+PipelineVertexInputDivisorStateCreateInfoKHR& PipelineVertexInputDivisorStateCreateInfoKHR::operator=(
+    const PipelineVertexInputDivisorStateCreateInfoKHR& 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;
+}
+
+PipelineVertexInputDivisorStateCreateInfoKHR::~PipelineVertexInputDivisorStateCreateInfoKHR() {
+    if (pVertexBindingDivisors) delete[] pVertexBindingDivisors;
+    FreePnextChain(pNext);
+}
+
+void PipelineVertexInputDivisorStateCreateInfoKHR::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 PipelineVertexInputDivisorStateCreateInfoKHR::initialize(const PipelineVertexInputDivisorStateCreateInfoKHR* 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);
+    }
+}
+
+PhysicalDeviceVertexAttributeDivisorFeaturesKHR::PhysicalDeviceVertexAttributeDivisorFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceVertexAttributeDivisorFeaturesKHR::PhysicalDeviceVertexAttributeDivisorFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR),
+      pNext(nullptr),
+      vertexAttributeInstanceRateDivisor(),
+      vertexAttributeInstanceRateZeroDivisor() {}
+
+PhysicalDeviceVertexAttributeDivisorFeaturesKHR::PhysicalDeviceVertexAttributeDivisorFeaturesKHR(
+    const PhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceVertexAttributeDivisorFeaturesKHR& PhysicalDeviceVertexAttributeDivisorFeaturesKHR::operator=(
+    const PhysicalDeviceVertexAttributeDivisorFeaturesKHR& 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;
+}
+
+PhysicalDeviceVertexAttributeDivisorFeaturesKHR::~PhysicalDeviceVertexAttributeDivisorFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceVertexAttributeDivisorFeaturesKHR::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 PhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize(const PhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderFloatControls2FeaturesKHR::PhysicalDeviceShaderFloatControls2FeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceShaderFloatControls2FeaturesKHR::PhysicalDeviceShaderFloatControls2FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR), pNext(nullptr), shaderFloatControls2() {}
+
+PhysicalDeviceShaderFloatControls2FeaturesKHR::PhysicalDeviceShaderFloatControls2FeaturesKHR(
+    const PhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderFloatControls2 = copy_src.shaderFloatControls2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderFloatControls2FeaturesKHR& PhysicalDeviceShaderFloatControls2FeaturesKHR::operator=(
+    const PhysicalDeviceShaderFloatControls2FeaturesKHR& 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;
+}
+
+PhysicalDeviceShaderFloatControls2FeaturesKHR::~PhysicalDeviceShaderFloatControls2FeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderFloatControls2FeaturesKHR::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 PhysicalDeviceShaderFloatControls2FeaturesKHR::initialize(const PhysicalDeviceShaderFloatControls2FeaturesKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderFloatControls2 = copy_src->shaderFloatControls2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceIndexTypeUint8FeaturesKHR::PhysicalDeviceIndexTypeUint8FeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceIndexTypeUint8FeaturesKHR::PhysicalDeviceIndexTypeUint8FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR), pNext(nullptr), indexTypeUint8() {}
+
+PhysicalDeviceIndexTypeUint8FeaturesKHR::PhysicalDeviceIndexTypeUint8FeaturesKHR(
+    const PhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    indexTypeUint8 = copy_src.indexTypeUint8;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceIndexTypeUint8FeaturesKHR& PhysicalDeviceIndexTypeUint8FeaturesKHR::operator=(
+    const PhysicalDeviceIndexTypeUint8FeaturesKHR& 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;
+}
+
+PhysicalDeviceIndexTypeUint8FeaturesKHR::~PhysicalDeviceIndexTypeUint8FeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceIndexTypeUint8FeaturesKHR::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 PhysicalDeviceIndexTypeUint8FeaturesKHR::initialize(const PhysicalDeviceIndexTypeUint8FeaturesKHR* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    indexTypeUint8 = copy_src->indexTypeUint8;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceLineRasterizationFeaturesKHR::PhysicalDeviceLineRasterizationFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceLineRasterizationFeaturesKHR::PhysicalDeviceLineRasterizationFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR),
+      pNext(nullptr),
+      rectangularLines(),
+      bresenhamLines(),
+      smoothLines(),
+      stippledRectangularLines(),
+      stippledBresenhamLines(),
+      stippledSmoothLines() {}
+
+PhysicalDeviceLineRasterizationFeaturesKHR::PhysicalDeviceLineRasterizationFeaturesKHR(
+    const PhysicalDeviceLineRasterizationFeaturesKHR& 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);
+}
+
+PhysicalDeviceLineRasterizationFeaturesKHR& PhysicalDeviceLineRasterizationFeaturesKHR::operator=(
+    const PhysicalDeviceLineRasterizationFeaturesKHR& 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;
+}
+
+PhysicalDeviceLineRasterizationFeaturesKHR::~PhysicalDeviceLineRasterizationFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceLineRasterizationFeaturesKHR::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 PhysicalDeviceLineRasterizationFeaturesKHR::initialize(const PhysicalDeviceLineRasterizationFeaturesKHR* 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);
+}
+
+PhysicalDeviceLineRasterizationPropertiesKHR::PhysicalDeviceLineRasterizationPropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceLineRasterizationPropertiesKHR::PhysicalDeviceLineRasterizationPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR), pNext(nullptr), lineSubPixelPrecisionBits() {}
+
+PhysicalDeviceLineRasterizationPropertiesKHR::PhysicalDeviceLineRasterizationPropertiesKHR(
+    const PhysicalDeviceLineRasterizationPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceLineRasterizationPropertiesKHR& PhysicalDeviceLineRasterizationPropertiesKHR::operator=(
+    const PhysicalDeviceLineRasterizationPropertiesKHR& 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;
+}
+
+PhysicalDeviceLineRasterizationPropertiesKHR::~PhysicalDeviceLineRasterizationPropertiesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceLineRasterizationPropertiesKHR::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 PhysicalDeviceLineRasterizationPropertiesKHR::initialize(const PhysicalDeviceLineRasterizationPropertiesKHR* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    lineSubPixelPrecisionBits = copy_src->lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineRasterizationLineStateCreateInfoKHR::PipelineRasterizationLineStateCreateInfoKHR(
+    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);
+    }
+}
+
+PipelineRasterizationLineStateCreateInfoKHR::PipelineRasterizationLineStateCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      lineRasterizationMode(),
+      stippledLineEnable(),
+      lineStippleFactor(),
+      lineStipplePattern() {}
+
+PipelineRasterizationLineStateCreateInfoKHR::PipelineRasterizationLineStateCreateInfoKHR(
+    const PipelineRasterizationLineStateCreateInfoKHR& 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);
+}
+
+PipelineRasterizationLineStateCreateInfoKHR& PipelineRasterizationLineStateCreateInfoKHR::operator=(
+    const PipelineRasterizationLineStateCreateInfoKHR& 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;
+}
+
+PipelineRasterizationLineStateCreateInfoKHR::~PipelineRasterizationLineStateCreateInfoKHR() { FreePnextChain(pNext); }
+
+void PipelineRasterizationLineStateCreateInfoKHR::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 PipelineRasterizationLineStateCreateInfoKHR::initialize(const PipelineRasterizationLineStateCreateInfoKHR* 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);
+}
+
+CalibratedTimestampInfoKHR::CalibratedTimestampInfoKHR(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);
+    }
+}
+
+CalibratedTimestampInfoKHR::CalibratedTimestampInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR), pNext(nullptr), timeDomain() {}
+
+CalibratedTimestampInfoKHR::CalibratedTimestampInfoKHR(const CalibratedTimestampInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    timeDomain = copy_src.timeDomain;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CalibratedTimestampInfoKHR& CalibratedTimestampInfoKHR::operator=(const CalibratedTimestampInfoKHR& 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;
+}
+
+CalibratedTimestampInfoKHR::~CalibratedTimestampInfoKHR() { FreePnextChain(pNext); }
+
+void CalibratedTimestampInfoKHR::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 CalibratedTimestampInfoKHR::initialize(const CalibratedTimestampInfoKHR* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    timeDomain = copy_src->timeDomain;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderExpectAssumeFeaturesKHR::PhysicalDeviceShaderExpectAssumeFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceShaderExpectAssumeFeaturesKHR::PhysicalDeviceShaderExpectAssumeFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR), pNext(nullptr), shaderExpectAssume() {}
+
+PhysicalDeviceShaderExpectAssumeFeaturesKHR::PhysicalDeviceShaderExpectAssumeFeaturesKHR(
+    const PhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderExpectAssume = copy_src.shaderExpectAssume;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderExpectAssumeFeaturesKHR& PhysicalDeviceShaderExpectAssumeFeaturesKHR::operator=(
+    const PhysicalDeviceShaderExpectAssumeFeaturesKHR& 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;
+}
+
+PhysicalDeviceShaderExpectAssumeFeaturesKHR::~PhysicalDeviceShaderExpectAssumeFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderExpectAssumeFeaturesKHR::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 PhysicalDeviceShaderExpectAssumeFeaturesKHR::initialize(const PhysicalDeviceShaderExpectAssumeFeaturesKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderExpectAssume = copy_src->shaderExpectAssume;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMaintenance6FeaturesKHR::PhysicalDeviceMaintenance6FeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceMaintenance6FeaturesKHR::PhysicalDeviceMaintenance6FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR), pNext(nullptr), maintenance6() {}
+
+PhysicalDeviceMaintenance6FeaturesKHR::PhysicalDeviceMaintenance6FeaturesKHR(
+    const PhysicalDeviceMaintenance6FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    maintenance6 = copy_src.maintenance6;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMaintenance6FeaturesKHR& PhysicalDeviceMaintenance6FeaturesKHR::operator=(
+    const PhysicalDeviceMaintenance6FeaturesKHR& 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;
+}
+
+PhysicalDeviceMaintenance6FeaturesKHR::~PhysicalDeviceMaintenance6FeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMaintenance6FeaturesKHR::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 PhysicalDeviceMaintenance6FeaturesKHR::initialize(const PhysicalDeviceMaintenance6FeaturesKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maintenance6 = copy_src->maintenance6;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMaintenance6PropertiesKHR::PhysicalDeviceMaintenance6PropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceMaintenance6PropertiesKHR::PhysicalDeviceMaintenance6PropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR),
+      pNext(nullptr),
+      blockTexelViewCompatibleMultipleLayers(),
+      maxCombinedImageSamplerDescriptorCount(),
+      fragmentShadingRateClampCombinerInputs() {}
+
+PhysicalDeviceMaintenance6PropertiesKHR::PhysicalDeviceMaintenance6PropertiesKHR(
+    const PhysicalDeviceMaintenance6PropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMaintenance6PropertiesKHR& PhysicalDeviceMaintenance6PropertiesKHR::operator=(
+    const PhysicalDeviceMaintenance6PropertiesKHR& 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;
+}
+
+PhysicalDeviceMaintenance6PropertiesKHR::~PhysicalDeviceMaintenance6PropertiesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMaintenance6PropertiesKHR::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 PhysicalDeviceMaintenance6PropertiesKHR::initialize(const PhysicalDeviceMaintenance6PropertiesKHR* 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);
+}
+
+BindMemoryStatusKHR::BindMemoryStatusKHR(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);
+    }
+}
+
+BindMemoryStatusKHR::BindMemoryStatusKHR() : sType(VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR), pNext(nullptr), pResult(nullptr) {}
+
+BindMemoryStatusKHR::BindMemoryStatusKHR(const BindMemoryStatusKHR& copy_src) {
+    sType = copy_src.sType;
+    pResult = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pResult) {
+        pResult = new VkResult(*copy_src.pResult);
+    }
+}
+
+BindMemoryStatusKHR& BindMemoryStatusKHR::operator=(const BindMemoryStatusKHR& 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;
+}
+
+BindMemoryStatusKHR::~BindMemoryStatusKHR() {
+    if (pResult) delete pResult;
+    FreePnextChain(pNext);
+}
+
+void BindMemoryStatusKHR::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 BindMemoryStatusKHR::initialize(const BindMemoryStatusKHR* 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);
+    }
+}
+
+BindDescriptorSetsInfoKHR::BindDescriptorSetsInfoKHR(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);
+    }
+}
+
+BindDescriptorSetsInfoKHR::BindDescriptorSetsInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR),
+      pNext(nullptr),
+      stageFlags(),
+      layout(),
+      firstSet(),
+      descriptorSetCount(),
+      pDescriptorSets(nullptr),
+      dynamicOffsetCount(),
+      pDynamicOffsets(nullptr) {}
+
+BindDescriptorSetsInfoKHR::BindDescriptorSetsInfoKHR(const BindDescriptorSetsInfoKHR& 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);
+    }
+}
+
+BindDescriptorSetsInfoKHR& BindDescriptorSetsInfoKHR::operator=(const BindDescriptorSetsInfoKHR& 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;
+}
+
+BindDescriptorSetsInfoKHR::~BindDescriptorSetsInfoKHR() {
+    if (pDescriptorSets) delete[] pDescriptorSets;
+    if (pDynamicOffsets) delete[] pDynamicOffsets;
+    FreePnextChain(pNext);
+}
+
+void BindDescriptorSetsInfoKHR::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 BindDescriptorSetsInfoKHR::initialize(const BindDescriptorSetsInfoKHR* 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);
+    }
+}
+
+PushConstantsInfoKHR::PushConstantsInfoKHR(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);
+    }
+}
+
+PushConstantsInfoKHR::PushConstantsInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR),
+      pNext(nullptr),
+      layout(),
+      stageFlags(),
+      offset(),
+      size(),
+      pValues(nullptr) {}
+
+PushConstantsInfoKHR::PushConstantsInfoKHR(const PushConstantsInfoKHR& 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);
+}
+
+PushConstantsInfoKHR& PushConstantsInfoKHR::operator=(const PushConstantsInfoKHR& 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;
+}
+
+PushConstantsInfoKHR::~PushConstantsInfoKHR() { FreePnextChain(pNext); }
+
+void PushConstantsInfoKHR::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 PushConstantsInfoKHR::initialize(const PushConstantsInfoKHR* 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);
+}
+
+PushDescriptorSetInfoKHR::PushDescriptorSetInfoKHR(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 WriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]);
+        }
+    }
+}
+
+PushDescriptorSetInfoKHR::PushDescriptorSetInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR),
+      pNext(nullptr),
+      stageFlags(),
+      layout(),
+      set(),
+      descriptorWriteCount(),
+      pDescriptorWrites(nullptr) {}
+
+PushDescriptorSetInfoKHR::PushDescriptorSetInfoKHR(const PushDescriptorSetInfoKHR& 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 WriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&copy_src.pDescriptorWrites[i]);
+        }
+    }
+}
+
+PushDescriptorSetInfoKHR& PushDescriptorSetInfoKHR::operator=(const PushDescriptorSetInfoKHR& 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 WriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&copy_src.pDescriptorWrites[i]);
+        }
+    }
+
+    return *this;
+}
+
+PushDescriptorSetInfoKHR::~PushDescriptorSetInfoKHR() {
+    if (pDescriptorWrites) delete[] pDescriptorWrites;
+    FreePnextChain(pNext);
+}
+
+void PushDescriptorSetInfoKHR::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 WriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]);
+        }
+    }
+}
+
+void PushDescriptorSetInfoKHR::initialize(const PushDescriptorSetInfoKHR* 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 WriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&copy_src->pDescriptorWrites[i]);
+        }
+    }
+}
+
+PushDescriptorSetWithTemplateInfoKHR::PushDescriptorSetWithTemplateInfoKHR(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);
+    }
+}
+
+PushDescriptorSetWithTemplateInfoKHR::PushDescriptorSetWithTemplateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR),
+      pNext(nullptr),
+      descriptorUpdateTemplate(),
+      layout(),
+      set(),
+      pData(nullptr) {}
+
+PushDescriptorSetWithTemplateInfoKHR::PushDescriptorSetWithTemplateInfoKHR(const PushDescriptorSetWithTemplateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PushDescriptorSetWithTemplateInfoKHR& PushDescriptorSetWithTemplateInfoKHR::operator=(
+    const PushDescriptorSetWithTemplateInfoKHR& 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;
+}
+
+PushDescriptorSetWithTemplateInfoKHR::~PushDescriptorSetWithTemplateInfoKHR() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+}
+
+void PushDescriptorSetWithTemplateInfoKHR::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 PushDescriptorSetWithTemplateInfoKHR::initialize(const PushDescriptorSetWithTemplateInfoKHR* 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);
+}
+
+DeviceOrHostAddressConstKHR::DeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct, PNextCopyState*) {
+    initialize(in_struct);
+}
+
+DeviceOrHostAddressConstKHR::DeviceOrHostAddressConstKHR() : hostAddress(nullptr) {}
+
+DeviceOrHostAddressConstKHR::DeviceOrHostAddressConstKHR(const DeviceOrHostAddressConstKHR& copy_src) {
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+}
+
+DeviceOrHostAddressConstKHR& DeviceOrHostAddressConstKHR::operator=(const DeviceOrHostAddressConstKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+
+    return *this;
+}
+
+DeviceOrHostAddressConstKHR::~DeviceOrHostAddressConstKHR() {}
+
+void DeviceOrHostAddressConstKHR::initialize(const VkDeviceOrHostAddressConstKHR* in_struct,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = in_struct->deviceAddress;
+    hostAddress = in_struct->hostAddress;
+}
+
+void DeviceOrHostAddressConstKHR::initialize(const DeviceOrHostAddressConstKHR* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = copy_src->deviceAddress;
+    hostAddress = copy_src->hostAddress;
+}
+
+DeviceOrHostAddressKHR::DeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* in_struct, PNextCopyState*) {
+    initialize(in_struct);
+}
+
+DeviceOrHostAddressKHR::DeviceOrHostAddressKHR() : hostAddress(nullptr) {}
+
+DeviceOrHostAddressKHR::DeviceOrHostAddressKHR(const DeviceOrHostAddressKHR& copy_src) {
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+}
+
+DeviceOrHostAddressKHR& DeviceOrHostAddressKHR::operator=(const DeviceOrHostAddressKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+
+    return *this;
+}
+
+DeviceOrHostAddressKHR::~DeviceOrHostAddressKHR() {}
+
+void DeviceOrHostAddressKHR::initialize(const VkDeviceOrHostAddressKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = in_struct->deviceAddress;
+    hostAddress = in_struct->hostAddress;
+}
+
+void DeviceOrHostAddressKHR::initialize(const DeviceOrHostAddressKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = copy_src->deviceAddress;
+    hostAddress = copy_src->hostAddress;
+}
+
+AccelerationStructureGeometryTrianglesDataKHR::AccelerationStructureGeometryTrianglesDataKHR(
+    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);
+    }
+}
+
+AccelerationStructureGeometryTrianglesDataKHR::AccelerationStructureGeometryTrianglesDataKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR),
+      pNext(nullptr),
+      vertexFormat(),
+      vertexStride(),
+      maxVertex(),
+      indexType() {}
+
+AccelerationStructureGeometryTrianglesDataKHR::AccelerationStructureGeometryTrianglesDataKHR(
+    const AccelerationStructureGeometryTrianglesDataKHR& 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);
+}
+
+AccelerationStructureGeometryTrianglesDataKHR& AccelerationStructureGeometryTrianglesDataKHR::operator=(
+    const AccelerationStructureGeometryTrianglesDataKHR& 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;
+}
+
+AccelerationStructureGeometryTrianglesDataKHR::~AccelerationStructureGeometryTrianglesDataKHR() { FreePnextChain(pNext); }
+
+void AccelerationStructureGeometryTrianglesDataKHR::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 AccelerationStructureGeometryTrianglesDataKHR::initialize(const AccelerationStructureGeometryTrianglesDataKHR* 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);
+}
+
+AccelerationStructureGeometryAabbsDataKHR::AccelerationStructureGeometryAabbsDataKHR(
+    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);
+    }
+}
+
+AccelerationStructureGeometryAabbsDataKHR::AccelerationStructureGeometryAabbsDataKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR), pNext(nullptr), stride() {}
+
+AccelerationStructureGeometryAabbsDataKHR::AccelerationStructureGeometryAabbsDataKHR(
+    const AccelerationStructureGeometryAabbsDataKHR& copy_src) {
+    sType = copy_src.sType;
+    data.initialize(&copy_src.data);
+    stride = copy_src.stride;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AccelerationStructureGeometryAabbsDataKHR& AccelerationStructureGeometryAabbsDataKHR::operator=(
+    const AccelerationStructureGeometryAabbsDataKHR& 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;
+}
+
+AccelerationStructureGeometryAabbsDataKHR::~AccelerationStructureGeometryAabbsDataKHR() { FreePnextChain(pNext); }
+
+void AccelerationStructureGeometryAabbsDataKHR::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 AccelerationStructureGeometryAabbsDataKHR::initialize(const AccelerationStructureGeometryAabbsDataKHR* 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);
+}
+
+AccelerationStructureGeometryInstancesDataKHR::AccelerationStructureGeometryInstancesDataKHR(
+    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);
+    }
+}
+
+AccelerationStructureGeometryInstancesDataKHR::AccelerationStructureGeometryInstancesDataKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR), pNext(nullptr), arrayOfPointers() {}
+
+AccelerationStructureGeometryInstancesDataKHR::AccelerationStructureGeometryInstancesDataKHR(
+    const AccelerationStructureGeometryInstancesDataKHR& copy_src) {
+    sType = copy_src.sType;
+    arrayOfPointers = copy_src.arrayOfPointers;
+    data.initialize(&copy_src.data);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AccelerationStructureGeometryInstancesDataKHR& AccelerationStructureGeometryInstancesDataKHR::operator=(
+    const AccelerationStructureGeometryInstancesDataKHR& 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;
+}
+
+AccelerationStructureGeometryInstancesDataKHR::~AccelerationStructureGeometryInstancesDataKHR() { FreePnextChain(pNext); }
+
+void AccelerationStructureGeometryInstancesDataKHR::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 AccelerationStructureGeometryInstancesDataKHR::initialize(const AccelerationStructureGeometryInstancesDataKHR* 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);
+}
+
+AccelerationStructureCreateInfoKHR::AccelerationStructureCreateInfoKHR(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);
+    }
+}
+
+AccelerationStructureCreateInfoKHR::AccelerationStructureCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      createFlags(),
+      buffer(),
+      offset(),
+      size(),
+      type(),
+      deviceAddress() {}
+
+AccelerationStructureCreateInfoKHR::AccelerationStructureCreateInfoKHR(const AccelerationStructureCreateInfoKHR& 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);
+}
+
+AccelerationStructureCreateInfoKHR& AccelerationStructureCreateInfoKHR::operator=(
+    const AccelerationStructureCreateInfoKHR& 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;
+}
+
+AccelerationStructureCreateInfoKHR::~AccelerationStructureCreateInfoKHR() { FreePnextChain(pNext); }
+
+void AccelerationStructureCreateInfoKHR::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 AccelerationStructureCreateInfoKHR::initialize(const AccelerationStructureCreateInfoKHR* 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);
+}
+
+WriteDescriptorSetAccelerationStructureKHR::WriteDescriptorSetAccelerationStructureKHR(
+    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];
+        }
+    }
+}
+
+WriteDescriptorSetAccelerationStructureKHR::WriteDescriptorSetAccelerationStructureKHR()
+    : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR),
+      pNext(nullptr),
+      accelerationStructureCount(),
+      pAccelerationStructures(nullptr) {}
+
+WriteDescriptorSetAccelerationStructureKHR::WriteDescriptorSetAccelerationStructureKHR(
+    const WriteDescriptorSetAccelerationStructureKHR& 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];
+        }
+    }
+}
+
+WriteDescriptorSetAccelerationStructureKHR& WriteDescriptorSetAccelerationStructureKHR::operator=(
+    const WriteDescriptorSetAccelerationStructureKHR& 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;
+}
+
+WriteDescriptorSetAccelerationStructureKHR::~WriteDescriptorSetAccelerationStructureKHR() {
+    if (pAccelerationStructures) delete[] pAccelerationStructures;
+    FreePnextChain(pNext);
+}
+
+void WriteDescriptorSetAccelerationStructureKHR::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 WriteDescriptorSetAccelerationStructureKHR::initialize(const WriteDescriptorSetAccelerationStructureKHR* 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];
+        }
+    }
+}
+
+PhysicalDeviceAccelerationStructureFeaturesKHR::PhysicalDeviceAccelerationStructureFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceAccelerationStructureFeaturesKHR::PhysicalDeviceAccelerationStructureFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR),
+      pNext(nullptr),
+      accelerationStructure(),
+      accelerationStructureCaptureReplay(),
+      accelerationStructureIndirectBuild(),
+      accelerationStructureHostCommands(),
+      descriptorBindingAccelerationStructureUpdateAfterBind() {}
+
+PhysicalDeviceAccelerationStructureFeaturesKHR::PhysicalDeviceAccelerationStructureFeaturesKHR(
+    const PhysicalDeviceAccelerationStructureFeaturesKHR& 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);
+}
+
+PhysicalDeviceAccelerationStructureFeaturesKHR& PhysicalDeviceAccelerationStructureFeaturesKHR::operator=(
+    const PhysicalDeviceAccelerationStructureFeaturesKHR& 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;
+}
+
+PhysicalDeviceAccelerationStructureFeaturesKHR::~PhysicalDeviceAccelerationStructureFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceAccelerationStructureFeaturesKHR::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 PhysicalDeviceAccelerationStructureFeaturesKHR::initialize(const PhysicalDeviceAccelerationStructureFeaturesKHR* 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);
+}
+
+PhysicalDeviceAccelerationStructurePropertiesKHR::PhysicalDeviceAccelerationStructurePropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceAccelerationStructurePropertiesKHR::PhysicalDeviceAccelerationStructurePropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR),
+      pNext(nullptr),
+      maxGeometryCount(),
+      maxInstanceCount(),
+      maxPrimitiveCount(),
+      maxPerStageDescriptorAccelerationStructures(),
+      maxPerStageDescriptorUpdateAfterBindAccelerationStructures(),
+      maxDescriptorSetAccelerationStructures(),
+      maxDescriptorSetUpdateAfterBindAccelerationStructures(),
+      minAccelerationStructureScratchOffsetAlignment() {}
+
+PhysicalDeviceAccelerationStructurePropertiesKHR::PhysicalDeviceAccelerationStructurePropertiesKHR(
+    const PhysicalDeviceAccelerationStructurePropertiesKHR& 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);
+}
+
+PhysicalDeviceAccelerationStructurePropertiesKHR& PhysicalDeviceAccelerationStructurePropertiesKHR::operator=(
+    const PhysicalDeviceAccelerationStructurePropertiesKHR& 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;
+}
+
+PhysicalDeviceAccelerationStructurePropertiesKHR::~PhysicalDeviceAccelerationStructurePropertiesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceAccelerationStructurePropertiesKHR::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 PhysicalDeviceAccelerationStructurePropertiesKHR::initialize(const PhysicalDeviceAccelerationStructurePropertiesKHR* 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);
+}
+
+AccelerationStructureDeviceAddressInfoKHR::AccelerationStructureDeviceAddressInfoKHR(
+    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);
+    }
+}
+
+AccelerationStructureDeviceAddressInfoKHR::AccelerationStructureDeviceAddressInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR), pNext(nullptr), accelerationStructure() {}
+
+AccelerationStructureDeviceAddressInfoKHR::AccelerationStructureDeviceAddressInfoKHR(
+    const AccelerationStructureDeviceAddressInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructure = copy_src.accelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AccelerationStructureDeviceAddressInfoKHR& AccelerationStructureDeviceAddressInfoKHR::operator=(
+    const AccelerationStructureDeviceAddressInfoKHR& 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;
+}
+
+AccelerationStructureDeviceAddressInfoKHR::~AccelerationStructureDeviceAddressInfoKHR() { FreePnextChain(pNext); }
+
+void AccelerationStructureDeviceAddressInfoKHR::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 AccelerationStructureDeviceAddressInfoKHR::initialize(const AccelerationStructureDeviceAddressInfoKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    accelerationStructure = copy_src->accelerationStructure;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+AccelerationStructureVersionInfoKHR::AccelerationStructureVersionInfoKHR(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);
+    }
+}
+
+AccelerationStructureVersionInfoKHR::AccelerationStructureVersionInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR), pNext(nullptr), pVersionData(nullptr) {}
+
+AccelerationStructureVersionInfoKHR::AccelerationStructureVersionInfoKHR(const AccelerationStructureVersionInfoKHR& 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);
+    }
+}
+
+AccelerationStructureVersionInfoKHR& AccelerationStructureVersionInfoKHR::operator=(
+    const AccelerationStructureVersionInfoKHR& 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;
+}
+
+AccelerationStructureVersionInfoKHR::~AccelerationStructureVersionInfoKHR() {
+    if (pVersionData) delete[] pVersionData;
+    FreePnextChain(pNext);
+}
+
+void AccelerationStructureVersionInfoKHR::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 AccelerationStructureVersionInfoKHR::initialize(const AccelerationStructureVersionInfoKHR* 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);
+    }
+}
+
+CopyAccelerationStructureToMemoryInfoKHR::CopyAccelerationStructureToMemoryInfoKHR(
+    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);
+    }
+}
+
+CopyAccelerationStructureToMemoryInfoKHR::CopyAccelerationStructureToMemoryInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR), pNext(nullptr), src(), mode() {}
+
+CopyAccelerationStructureToMemoryInfoKHR::CopyAccelerationStructureToMemoryInfoKHR(
+    const CopyAccelerationStructureToMemoryInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst.initialize(&copy_src.dst);
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CopyAccelerationStructureToMemoryInfoKHR& CopyAccelerationStructureToMemoryInfoKHR::operator=(
+    const CopyAccelerationStructureToMemoryInfoKHR& 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;
+}
+
+CopyAccelerationStructureToMemoryInfoKHR::~CopyAccelerationStructureToMemoryInfoKHR() { FreePnextChain(pNext); }
+
+void CopyAccelerationStructureToMemoryInfoKHR::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 CopyAccelerationStructureToMemoryInfoKHR::initialize(const CopyAccelerationStructureToMemoryInfoKHR* 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);
+}
+
+CopyMemoryToAccelerationStructureInfoKHR::CopyMemoryToAccelerationStructureInfoKHR(
+    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);
+    }
+}
+
+CopyMemoryToAccelerationStructureInfoKHR::CopyMemoryToAccelerationStructureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR), pNext(nullptr), dst(), mode() {}
+
+CopyMemoryToAccelerationStructureInfoKHR::CopyMemoryToAccelerationStructureInfoKHR(
+    const CopyMemoryToAccelerationStructureInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    src.initialize(&copy_src.src);
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CopyMemoryToAccelerationStructureInfoKHR& CopyMemoryToAccelerationStructureInfoKHR::operator=(
+    const CopyMemoryToAccelerationStructureInfoKHR& 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;
+}
+
+CopyMemoryToAccelerationStructureInfoKHR::~CopyMemoryToAccelerationStructureInfoKHR() { FreePnextChain(pNext); }
+
+void CopyMemoryToAccelerationStructureInfoKHR::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 CopyMemoryToAccelerationStructureInfoKHR::initialize(const CopyMemoryToAccelerationStructureInfoKHR* 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);
+}
+
+CopyAccelerationStructureInfoKHR::CopyAccelerationStructureInfoKHR(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);
+    }
+}
+
+CopyAccelerationStructureInfoKHR::CopyAccelerationStructureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR), pNext(nullptr), src(), dst(), mode() {}
+
+CopyAccelerationStructureInfoKHR::CopyAccelerationStructureInfoKHR(const CopyAccelerationStructureInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CopyAccelerationStructureInfoKHR& CopyAccelerationStructureInfoKHR::operator=(const CopyAccelerationStructureInfoKHR& 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;
+}
+
+CopyAccelerationStructureInfoKHR::~CopyAccelerationStructureInfoKHR() { FreePnextChain(pNext); }
+
+void CopyAccelerationStructureInfoKHR::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 CopyAccelerationStructureInfoKHR::initialize(const CopyAccelerationStructureInfoKHR* 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);
+}
+
+AccelerationStructureBuildSizesInfoKHR::AccelerationStructureBuildSizesInfoKHR(
+    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);
+    }
+}
+
+AccelerationStructureBuildSizesInfoKHR::AccelerationStructureBuildSizesInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR),
+      pNext(nullptr),
+      accelerationStructureSize(),
+      updateScratchSize(),
+      buildScratchSize() {}
+
+AccelerationStructureBuildSizesInfoKHR::AccelerationStructureBuildSizesInfoKHR(
+    const AccelerationStructureBuildSizesInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructureSize = copy_src.accelerationStructureSize;
+    updateScratchSize = copy_src.updateScratchSize;
+    buildScratchSize = copy_src.buildScratchSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AccelerationStructureBuildSizesInfoKHR& AccelerationStructureBuildSizesInfoKHR::operator=(
+    const AccelerationStructureBuildSizesInfoKHR& 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;
+}
+
+AccelerationStructureBuildSizesInfoKHR::~AccelerationStructureBuildSizesInfoKHR() { FreePnextChain(pNext); }
+
+void AccelerationStructureBuildSizesInfoKHR::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 AccelerationStructureBuildSizesInfoKHR::initialize(const AccelerationStructureBuildSizesInfoKHR* 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);
+}
+
+RayTracingShaderGroupCreateInfoKHR::RayTracingShaderGroupCreateInfoKHR(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);
+    }
+}
+
+RayTracingShaderGroupCreateInfoKHR::RayTracingShaderGroupCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR),
+      pNext(nullptr),
+      type(),
+      generalShader(),
+      closestHitShader(),
+      anyHitShader(),
+      intersectionShader(),
+      pShaderGroupCaptureReplayHandle(nullptr) {}
+
+RayTracingShaderGroupCreateInfoKHR::RayTracingShaderGroupCreateInfoKHR(const RayTracingShaderGroupCreateInfoKHR& 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);
+}
+
+RayTracingShaderGroupCreateInfoKHR& RayTracingShaderGroupCreateInfoKHR::operator=(
+    const RayTracingShaderGroupCreateInfoKHR& 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;
+}
+
+RayTracingShaderGroupCreateInfoKHR::~RayTracingShaderGroupCreateInfoKHR() { FreePnextChain(pNext); }
+
+void RayTracingShaderGroupCreateInfoKHR::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 RayTracingShaderGroupCreateInfoKHR::initialize(const RayTracingShaderGroupCreateInfoKHR* 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);
+}
+
+RayTracingPipelineInterfaceCreateInfoKHR::RayTracingPipelineInterfaceCreateInfoKHR(
+    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);
+    }
+}
+
+RayTracingPipelineInterfaceCreateInfoKHR::RayTracingPipelineInterfaceCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      maxPipelineRayPayloadSize(),
+      maxPipelineRayHitAttributeSize() {}
+
+RayTracingPipelineInterfaceCreateInfoKHR::RayTracingPipelineInterfaceCreateInfoKHR(
+    const RayTracingPipelineInterfaceCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    maxPipelineRayPayloadSize = copy_src.maxPipelineRayPayloadSize;
+    maxPipelineRayHitAttributeSize = copy_src.maxPipelineRayHitAttributeSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+RayTracingPipelineInterfaceCreateInfoKHR& RayTracingPipelineInterfaceCreateInfoKHR::operator=(
+    const RayTracingPipelineInterfaceCreateInfoKHR& 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;
+}
+
+RayTracingPipelineInterfaceCreateInfoKHR::~RayTracingPipelineInterfaceCreateInfoKHR() { FreePnextChain(pNext); }
+
+void RayTracingPipelineInterfaceCreateInfoKHR::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 RayTracingPipelineInterfaceCreateInfoKHR::initialize(const RayTracingPipelineInterfaceCreateInfoKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxPipelineRayPayloadSize = copy_src->maxPipelineRayPayloadSize;
+    maxPipelineRayHitAttributeSize = copy_src->maxPipelineRayHitAttributeSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+RayTracingPipelineCreateInfoKHR::RayTracingPipelineCreateInfoKHR(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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (groupCount && in_struct->pGroups) {
+        pGroups = new RayTracingShaderGroupCreateInfoKHR[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&in_struct->pGroups[i]);
+        }
+    }
+    if (in_struct->pLibraryInfo) pLibraryInfo = new PipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo);
+    if (in_struct->pLibraryInterface)
+        pLibraryInterface = new RayTracingPipelineInterfaceCreateInfoKHR(in_struct->pLibraryInterface);
+    if (in_struct->pDynamicState) pDynamicState = new PipelineDynamicStateCreateInfo(in_struct->pDynamicState);
+}
+
+RayTracingPipelineCreateInfoKHR::RayTracingPipelineCreateInfoKHR()
+    : 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() {}
+
+RayTracingPipelineCreateInfoKHR::RayTracingPipelineCreateInfoKHR(const RayTracingPipelineCreateInfoKHR& 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (groupCount && copy_src.pGroups) {
+        pGroups = new RayTracingShaderGroupCreateInfoKHR[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src.pGroups[i]);
+        }
+    }
+    if (copy_src.pLibraryInfo) pLibraryInfo = new PipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo);
+    if (copy_src.pLibraryInterface) pLibraryInterface = new RayTracingPipelineInterfaceCreateInfoKHR(*copy_src.pLibraryInterface);
+    if (copy_src.pDynamicState) pDynamicState = new PipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
+}
+
+RayTracingPipelineCreateInfoKHR& RayTracingPipelineCreateInfoKHR::operator=(const RayTracingPipelineCreateInfoKHR& 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (groupCount && copy_src.pGroups) {
+        pGroups = new RayTracingShaderGroupCreateInfoKHR[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src.pGroups[i]);
+        }
+    }
+    if (copy_src.pLibraryInfo) pLibraryInfo = new PipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo);
+    if (copy_src.pLibraryInterface) pLibraryInterface = new RayTracingPipelineInterfaceCreateInfoKHR(*copy_src.pLibraryInterface);
+    if (copy_src.pDynamicState) pDynamicState = new PipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
+
+    return *this;
+}
+
+RayTracingPipelineCreateInfoKHR::~RayTracingPipelineCreateInfoKHR() {
+    if (pStages) delete[] pStages;
+    if (pGroups) delete[] pGroups;
+    if (pLibraryInfo) delete pLibraryInfo;
+    if (pLibraryInterface) delete pLibraryInterface;
+    if (pDynamicState) delete pDynamicState;
+    FreePnextChain(pNext);
+}
+
+void RayTracingPipelineCreateInfoKHR::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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (groupCount && in_struct->pGroups) {
+        pGroups = new RayTracingShaderGroupCreateInfoKHR[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&in_struct->pGroups[i]);
+        }
+    }
+    if (in_struct->pLibraryInfo) pLibraryInfo = new PipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo);
+    if (in_struct->pLibraryInterface)
+        pLibraryInterface = new RayTracingPipelineInterfaceCreateInfoKHR(in_struct->pLibraryInterface);
+    if (in_struct->pDynamicState) pDynamicState = new PipelineDynamicStateCreateInfo(in_struct->pDynamicState);
+}
+
+void RayTracingPipelineCreateInfoKHR::initialize(const RayTracingPipelineCreateInfoKHR* 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src->pStages[i]);
+        }
+    }
+    if (groupCount && copy_src->pGroups) {
+        pGroups = new RayTracingShaderGroupCreateInfoKHR[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src->pGroups[i]);
+        }
+    }
+    if (copy_src->pLibraryInfo) pLibraryInfo = new PipelineLibraryCreateInfoKHR(*copy_src->pLibraryInfo);
+    if (copy_src->pLibraryInterface) pLibraryInterface = new RayTracingPipelineInterfaceCreateInfoKHR(*copy_src->pLibraryInterface);
+    if (copy_src->pDynamicState) pDynamicState = new PipelineDynamicStateCreateInfo(*copy_src->pDynamicState);
+}
+
+PhysicalDeviceRayTracingPipelineFeaturesKHR::PhysicalDeviceRayTracingPipelineFeaturesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceRayTracingPipelineFeaturesKHR::PhysicalDeviceRayTracingPipelineFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR),
+      pNext(nullptr),
+      rayTracingPipeline(),
+      rayTracingPipelineShaderGroupHandleCaptureReplay(),
+      rayTracingPipelineShaderGroupHandleCaptureReplayMixed(),
+      rayTracingPipelineTraceRaysIndirect(),
+      rayTraversalPrimitiveCulling() {}
+
+PhysicalDeviceRayTracingPipelineFeaturesKHR::PhysicalDeviceRayTracingPipelineFeaturesKHR(
+    const PhysicalDeviceRayTracingPipelineFeaturesKHR& 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);
+}
+
+PhysicalDeviceRayTracingPipelineFeaturesKHR& PhysicalDeviceRayTracingPipelineFeaturesKHR::operator=(
+    const PhysicalDeviceRayTracingPipelineFeaturesKHR& 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;
+}
+
+PhysicalDeviceRayTracingPipelineFeaturesKHR::~PhysicalDeviceRayTracingPipelineFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRayTracingPipelineFeaturesKHR::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 PhysicalDeviceRayTracingPipelineFeaturesKHR::initialize(const PhysicalDeviceRayTracingPipelineFeaturesKHR* 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);
+}
+
+PhysicalDeviceRayTracingPipelinePropertiesKHR::PhysicalDeviceRayTracingPipelinePropertiesKHR(
+    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);
+    }
+}
+
+PhysicalDeviceRayTracingPipelinePropertiesKHR::PhysicalDeviceRayTracingPipelinePropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR),
+      pNext(nullptr),
+      shaderGroupHandleSize(),
+      maxRayRecursionDepth(),
+      maxShaderGroupStride(),
+      shaderGroupBaseAlignment(),
+      shaderGroupHandleCaptureReplaySize(),
+      maxRayDispatchInvocationCount(),
+      shaderGroupHandleAlignment(),
+      maxRayHitAttributeSize() {}
+
+PhysicalDeviceRayTracingPipelinePropertiesKHR::PhysicalDeviceRayTracingPipelinePropertiesKHR(
+    const PhysicalDeviceRayTracingPipelinePropertiesKHR& 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);
+}
+
+PhysicalDeviceRayTracingPipelinePropertiesKHR& PhysicalDeviceRayTracingPipelinePropertiesKHR::operator=(
+    const PhysicalDeviceRayTracingPipelinePropertiesKHR& 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;
+}
+
+PhysicalDeviceRayTracingPipelinePropertiesKHR::~PhysicalDeviceRayTracingPipelinePropertiesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRayTracingPipelinePropertiesKHR::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 PhysicalDeviceRayTracingPipelinePropertiesKHR::initialize(const PhysicalDeviceRayTracingPipelinePropertiesKHR* 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);
+}
+
+PhysicalDeviceRayQueryFeaturesKHR::PhysicalDeviceRayQueryFeaturesKHR(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);
+    }
+}
+
+PhysicalDeviceRayQueryFeaturesKHR::PhysicalDeviceRayQueryFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR), pNext(nullptr), rayQuery() {}
+
+PhysicalDeviceRayQueryFeaturesKHR::PhysicalDeviceRayQueryFeaturesKHR(const PhysicalDeviceRayQueryFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    rayQuery = copy_src.rayQuery;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRayQueryFeaturesKHR& PhysicalDeviceRayQueryFeaturesKHR::operator=(const PhysicalDeviceRayQueryFeaturesKHR& 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;
+}
+
+PhysicalDeviceRayQueryFeaturesKHR::~PhysicalDeviceRayQueryFeaturesKHR() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRayQueryFeaturesKHR::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 PhysicalDeviceRayQueryFeaturesKHR::initialize(const PhysicalDeviceRayQueryFeaturesKHR* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayQuery = copy_src->rayQuery;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+}  // namespace safe
+}  // 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..6ecf5ca
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_manual.cpp
@@ -0,0 +1,2197 @@
+/***************************************************************************
+ *
+ * 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/concurrent_unordered_map.hpp>
+
+#include <cassert>
+#include <cstring>
+
+namespace vku {
+namespace safe {
+
+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 AccelerationStructureGeometryKHR*, ASGeomKHRExtraData*, 4> as_geom_khr_host_alloc;
+
+AccelerationStructureGeometryKHR::AccelerationStructureGeometryKHR(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));
+        }
+    }
+}
+
+AccelerationStructureGeometryKHR::AccelerationStructureGeometryKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR), pNext(nullptr), geometryType(), geometry(), flags() {}
+
+AccelerationStructureGeometryKHR::AccelerationStructureGeometryKHR(const AccelerationStructureGeometryKHR& 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));
+        }
+    }
+}
+
+AccelerationStructureGeometryKHR& AccelerationStructureGeometryKHR::operator=(const AccelerationStructureGeometryKHR& 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;
+}
+
+AccelerationStructureGeometryKHR::~AccelerationStructureGeometryKHR() {
+    auto iter = as_geom_khr_host_alloc.pop(this);
+    if (iter != as_geom_khr_host_alloc.end()) {
+        delete iter->second;
+    }
+    FreePnextChain(pNext);
+}
+
+void AccelerationStructureGeometryKHR::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 AccelerationStructureGeometryKHR::initialize(const AccelerationStructureGeometryKHR* 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 RayTracingPipelineCreateInfoCommon::initialize(const VkRayTracingPipelineCreateInfoNV* pCreateInfo) {
+    RayTracingPipelineCreateInfoNV 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 RayTracingShaderGroupCreateInfoKHR[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 RayTracingPipelineCreateInfoCommon::initialize(const VkRayTracingPipelineCreateInfoKHR* pCreateInfo) {
+    RayTracingPipelineCreateInfoKHR::initialize(pCreateInfo);
+}
+
+DescriptorDataEXT::DescriptorDataEXT(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 DescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer =
+                in_struct->pStorageTexelBuffer ? new DescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = in_struct->pUniformBuffer ? new DescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = in_struct->pStorageBuffer ? new DescriptorAddressInfoEXT(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;
+}
+
+DescriptorDataEXT::DescriptorDataEXT() : type_at_end{0} {
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+    *pType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
+}
+
+DescriptorDataEXT::DescriptorDataEXT(const DescriptorDataEXT& 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 DescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer = new DescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = new DescriptorAddressInfoEXT(*copy_src.pUniformBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = new DescriptorAddressInfoEXT(*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;
+}
+
+DescriptorDataEXT& DescriptorDataEXT::operator=(const DescriptorDataEXT& 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 DescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer = new DescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = new DescriptorAddressInfoEXT(*copy_src.pUniformBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = new DescriptorAddressInfoEXT(*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;
+}
+
+DescriptorDataEXT::~DescriptorDataEXT() {
+    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 DescriptorDataEXT::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 DescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer =
+                in_struct->pStorageTexelBuffer ? new DescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = in_struct->pUniformBuffer ? new DescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = in_struct->pStorageBuffer ? new DescriptorAddressInfoEXT(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 DescriptorDataEXT::initialize(const DescriptorDataEXT* 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 DescriptorAddressInfoEXT(*copy_src->pUniformTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer = new DescriptorAddressInfoEXT(*copy_src->pStorageTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = new DescriptorAddressInfoEXT(*copy_src->pUniformBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = new DescriptorAddressInfoEXT(*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;
+}
+
+GraphicsPipelineCreateInfo::GraphicsPipelineCreateInfo(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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pVertexInputState)
+        pVertexInputState = new PipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
+    else
+        pVertexInputState = nullptr;
+    if (in_struct->pInputAssemblyState)
+        pInputAssemblyState = new PipelineInputAssemblyStateCreateInfo(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 PipelineTessellationStateCreateInfo(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 PipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors);
+    } else
+        pViewportState = nullptr;  // original pViewportState pointer ignored
+    if (in_struct->pRasterizationState)
+        pRasterizationState = new PipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
+    else
+        pRasterizationState = nullptr;
+    if (in_struct->pMultisampleState && (renderPass != VK_NULL_HANDLE || has_rasterization || is_graphics_library))
+        pMultisampleState = new PipelineMultisampleStateCreateInfo(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 PipelineDepthStencilStateCreateInfo(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 PipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);
+    else
+        pColorBlendState = nullptr;  // original pColorBlendState pointer ignored
+    if (in_struct->pDynamicState)
+        pDynamicState = new PipelineDynamicStateCreateInfo(in_struct->pDynamicState);
+    else
+        pDynamicState = nullptr;
+}
+
+GraphicsPipelineCreateInfo::GraphicsPipelineCreateInfo()
+    : 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() {}
+
+GraphicsPipelineCreateInfo::GraphicsPipelineCreateInfo(const GraphicsPipelineCreateInfo& 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pVertexInputState)
+        pVertexInputState = new PipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
+    else
+        pVertexInputState = nullptr;
+    if (copy_src.pInputAssemblyState)
+        pInputAssemblyState = new PipelineInputAssemblyStateCreateInfo(*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 PipelineTessellationStateCreateInfo(*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 PipelineViewportStateCreateInfo(*copy_src.pViewportState);
+    } else
+        pViewportState = nullptr;  // original pViewportState pointer ignored
+    if (copy_src.pRasterizationState)
+        pRasterizationState = new PipelineRasterizationStateCreateInfo(*copy_src.pRasterizationState);
+    else
+        pRasterizationState = nullptr;
+    if (copy_src.pMultisampleState && (has_rasterization || is_graphics_library))
+        pMultisampleState = new PipelineMultisampleStateCreateInfo(*copy_src.pMultisampleState);
+    else
+        pMultisampleState = nullptr;  // original pMultisampleState pointer ignored
+    if (copy_src.pDepthStencilState && (has_rasterization || is_graphics_library))
+        pDepthStencilState = new PipelineDepthStencilStateCreateInfo(*copy_src.pDepthStencilState);
+    else
+        pDepthStencilState = nullptr;  // original pDepthStencilState pointer ignored
+    if (copy_src.pColorBlendState && (has_rasterization || is_graphics_library))
+        pColorBlendState = new PipelineColorBlendStateCreateInfo(*copy_src.pColorBlendState);
+    else
+        pColorBlendState = nullptr;  // original pColorBlendState pointer ignored
+    if (copy_src.pDynamicState)
+        pDynamicState = new PipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
+    else
+        pDynamicState = nullptr;
+}
+
+GraphicsPipelineCreateInfo& GraphicsPipelineCreateInfo::operator=(const GraphicsPipelineCreateInfo& 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pVertexInputState)
+        pVertexInputState = new PipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
+    else
+        pVertexInputState = nullptr;
+    if (copy_src.pInputAssemblyState)
+        pInputAssemblyState = new PipelineInputAssemblyStateCreateInfo(*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 PipelineTessellationStateCreateInfo(*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 PipelineViewportStateCreateInfo(*copy_src.pViewportState);
+    } else
+        pViewportState = nullptr;  // original pViewportState pointer ignored
+    if (copy_src.pRasterizationState)
+        pRasterizationState = new PipelineRasterizationStateCreateInfo(*copy_src.pRasterizationState);
+    else
+        pRasterizationState = nullptr;
+    if (copy_src.pMultisampleState && (has_rasterization || is_graphics_library))
+        pMultisampleState = new PipelineMultisampleStateCreateInfo(*copy_src.pMultisampleState);
+    else
+        pMultisampleState = nullptr;  // original pMultisampleState pointer ignored
+    if (copy_src.pDepthStencilState && (has_rasterization || is_graphics_library))
+        pDepthStencilState = new PipelineDepthStencilStateCreateInfo(*copy_src.pDepthStencilState);
+    else
+        pDepthStencilState = nullptr;  // original pDepthStencilState pointer ignored
+    if (copy_src.pColorBlendState && (has_rasterization || is_graphics_library))
+        pColorBlendState = new PipelineColorBlendStateCreateInfo(*copy_src.pColorBlendState);
+    else
+        pColorBlendState = nullptr;  // original pColorBlendState pointer ignored
+    if (copy_src.pDynamicState)
+        pDynamicState = new PipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
+    else
+        pDynamicState = nullptr;
+
+    return *this;
+}
+
+GraphicsPipelineCreateInfo::~GraphicsPipelineCreateInfo() {
+    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 GraphicsPipelineCreateInfo::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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pVertexInputState)
+        pVertexInputState = new PipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
+    else
+        pVertexInputState = nullptr;
+    if (in_struct->pInputAssemblyState)
+        pInputAssemblyState = new PipelineInputAssemblyStateCreateInfo(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 PipelineTessellationStateCreateInfo(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 PipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors);
+    } else
+        pViewportState = nullptr;  // original pViewportState pointer ignored
+    if (in_struct->pRasterizationState)
+        pRasterizationState = new PipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
+    else
+        pRasterizationState = nullptr;
+    if (in_struct->pMultisampleState && (renderPass != VK_NULL_HANDLE || has_rasterization || is_graphics_library))
+        pMultisampleState = new PipelineMultisampleStateCreateInfo(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 PipelineDepthStencilStateCreateInfo(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 PipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);
+    else
+        pColorBlendState = nullptr;  // original pColorBlendState pointer ignored
+    if (in_struct->pDynamicState)
+        pDynamicState = new PipelineDynamicStateCreateInfo(in_struct->pDynamicState);
+    else
+        pDynamicState = nullptr;
+}
+
+void GraphicsPipelineCreateInfo::initialize(const GraphicsPipelineCreateInfo* 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src->pStages[i]);
+        }
+    }
+    if (copy_src->pVertexInputState)
+        pVertexInputState = new PipelineVertexInputStateCreateInfo(*copy_src->pVertexInputState);
+    else
+        pVertexInputState = nullptr;
+    if (copy_src->pInputAssemblyState)
+        pInputAssemblyState = new PipelineInputAssemblyStateCreateInfo(*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 PipelineTessellationStateCreateInfo(*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 PipelineViewportStateCreateInfo(*copy_src->pViewportState);
+    } else
+        pViewportState = nullptr;  // original pViewportState pointer ignored
+    if (copy_src->pRasterizationState)
+        pRasterizationState = new PipelineRasterizationStateCreateInfo(*copy_src->pRasterizationState);
+    else
+        pRasterizationState = nullptr;
+    if (copy_src->pMultisampleState && (has_rasterization || is_graphics_library))
+        pMultisampleState = new PipelineMultisampleStateCreateInfo(*copy_src->pMultisampleState);
+    else
+        pMultisampleState = nullptr;  // original pMultisampleState pointer ignored
+    if (copy_src->pDepthStencilState && (has_rasterization || is_graphics_library))
+        pDepthStencilState = new PipelineDepthStencilStateCreateInfo(*copy_src->pDepthStencilState);
+    else
+        pDepthStencilState = nullptr;  // original pDepthStencilState pointer ignored
+    if (copy_src->pColorBlendState && (has_rasterization || is_graphics_library))
+        pColorBlendState = new PipelineColorBlendStateCreateInfo(*copy_src->pColorBlendState);
+    else
+        pColorBlendState = nullptr;  // original pColorBlendState pointer ignored
+    if (copy_src->pDynamicState)
+        pDynamicState = new PipelineDynamicStateCreateInfo(*copy_src->pDynamicState);
+    else
+        pDynamicState = nullptr;
+}
+
+PipelineViewportStateCreateInfo::PipelineViewportStateCreateInfo(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;
+}
+
+PipelineViewportStateCreateInfo::PipelineViewportStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      viewportCount(),
+      pViewports(nullptr),
+      scissorCount(),
+      pScissors(nullptr) {}
+
+PipelineViewportStateCreateInfo::PipelineViewportStateCreateInfo(const PipelineViewportStateCreateInfo& 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;
+}
+
+PipelineViewportStateCreateInfo& PipelineViewportStateCreateInfo::operator=(const PipelineViewportStateCreateInfo& 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;
+}
+
+PipelineViewportStateCreateInfo::~PipelineViewportStateCreateInfo() {
+    if (pViewports) delete[] pViewports;
+    if (pScissors) delete[] pScissors;
+    FreePnextChain(pNext);
+}
+
+void PipelineViewportStateCreateInfo::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 PipelineViewportStateCreateInfo::initialize(const PipelineViewportStateCreateInfo* 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;
+}
+
+AccelerationStructureBuildGeometryInfoKHR::AccelerationStructureBuildGeometryInfoKHR(
+    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 AccelerationStructureGeometryKHR*[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                ppGeometries[i] = new AccelerationStructureGeometryKHR(in_struct->ppGeometries[i], is_host, &build_range_infos[i]);
+            }
+        } else {
+            pGeometries = new AccelerationStructureGeometryKHR[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                (pGeometries)[i] = AccelerationStructureGeometryKHR(&(in_struct->pGeometries)[i], is_host, &build_range_infos[i]);
+            }
+        }
+    }
+}
+
+AccelerationStructureBuildGeometryInfoKHR::AccelerationStructureBuildGeometryInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR),
+      pNext(nullptr),
+      type(),
+      flags(),
+      mode(),
+      srcAccelerationStructure(),
+      dstAccelerationStructure(),
+      geometryCount(),
+      pGeometries(nullptr),
+      ppGeometries(nullptr) {}
+
+AccelerationStructureBuildGeometryInfoKHR::AccelerationStructureBuildGeometryInfoKHR(
+    const AccelerationStructureBuildGeometryInfoKHR& 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 AccelerationStructureGeometryKHR*[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                ppGeometries[i] = new AccelerationStructureGeometryKHR(*copy_src.ppGeometries[i]);
+            }
+        } else {
+            pGeometries = new AccelerationStructureGeometryKHR[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                pGeometries[i] = AccelerationStructureGeometryKHR(copy_src.pGeometries[i]);
+            }
+        }
+    }
+}
+
+AccelerationStructureBuildGeometryInfoKHR& AccelerationStructureBuildGeometryInfoKHR::operator=(
+    const AccelerationStructureBuildGeometryInfoKHR& 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 AccelerationStructureGeometryKHR*[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                ppGeometries[i] = new AccelerationStructureGeometryKHR(*copy_src.ppGeometries[i]);
+            }
+        } else {
+            pGeometries = new AccelerationStructureGeometryKHR[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                pGeometries[i] = AccelerationStructureGeometryKHR(copy_src.pGeometries[i]);
+            }
+        }
+    }
+
+    return *this;
+}
+
+AccelerationStructureBuildGeometryInfoKHR::~AccelerationStructureBuildGeometryInfoKHR() {
+    if (ppGeometries) {
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            delete ppGeometries[i];
+        }
+        delete[] ppGeometries;
+    } else if (pGeometries) {
+        delete[] pGeometries;
+    }
+    FreePnextChain(pNext);
+}
+
+void AccelerationStructureBuildGeometryInfoKHR::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 AccelerationStructureGeometryKHR*[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                ppGeometries[i] = new AccelerationStructureGeometryKHR(in_struct->ppGeometries[i], is_host, &build_range_infos[i]);
+            }
+        } else {
+            pGeometries = new AccelerationStructureGeometryKHR[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                (pGeometries)[i] = AccelerationStructureGeometryKHR(&(in_struct->pGeometries)[i], is_host, &build_range_infos[i]);
+            }
+        }
+    }
+}
+
+void AccelerationStructureBuildGeometryInfoKHR::initialize(const AccelerationStructureBuildGeometryInfoKHR* 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 AccelerationStructureGeometryKHR*[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                ppGeometries[i] = new AccelerationStructureGeometryKHR(*copy_src->ppGeometries[i]);
+            }
+        } else {
+            pGeometries = new AccelerationStructureGeometryKHR[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                pGeometries[i] = AccelerationStructureGeometryKHR(copy_src->pGeometries[i]);
+            }
+        }
+    }
+}
+
+MicromapBuildInfoEXT::MicromapBuildInfoEXT(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;
+    }
+}
+
+MicromapBuildInfoEXT::MicromapBuildInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT),
+      pNext(nullptr),
+      type(),
+      flags(),
+      mode(),
+      dstMicromap(),
+      usageCountsCount(),
+      pUsageCounts(nullptr),
+      ppUsageCounts(nullptr),
+      triangleArrayStride() {}
+
+MicromapBuildInfoEXT::MicromapBuildInfoEXT(const MicromapBuildInfoEXT& 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;
+    }
+}
+
+MicromapBuildInfoEXT& MicromapBuildInfoEXT::operator=(const MicromapBuildInfoEXT& 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;
+}
+
+MicromapBuildInfoEXT::~MicromapBuildInfoEXT() {
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+}
+
+void MicromapBuildInfoEXT::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 MicromapBuildInfoEXT::initialize(const MicromapBuildInfoEXT* 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;
+    }
+}
+
+AccelerationStructureTrianglesOpacityMicromapEXT::AccelerationStructureTrianglesOpacityMicromapEXT(
+    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;
+    }
+}
+
+AccelerationStructureTrianglesOpacityMicromapEXT::AccelerationStructureTrianglesOpacityMicromapEXT()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT),
+      pNext(nullptr),
+      indexType(),
+      indexStride(),
+      baseTriangle(),
+      usageCountsCount(),
+      pUsageCounts(nullptr),
+      ppUsageCounts(nullptr),
+      micromap() {}
+
+AccelerationStructureTrianglesOpacityMicromapEXT::AccelerationStructureTrianglesOpacityMicromapEXT(
+    const AccelerationStructureTrianglesOpacityMicromapEXT& 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;
+    }
+}
+
+AccelerationStructureTrianglesOpacityMicromapEXT& AccelerationStructureTrianglesOpacityMicromapEXT::operator=(
+    const AccelerationStructureTrianglesOpacityMicromapEXT& 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;
+}
+
+AccelerationStructureTrianglesOpacityMicromapEXT::~AccelerationStructureTrianglesOpacityMicromapEXT() {
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+}
+
+void AccelerationStructureTrianglesOpacityMicromapEXT::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 AccelerationStructureTrianglesOpacityMicromapEXT::initialize(const AccelerationStructureTrianglesOpacityMicromapEXT* 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
+AccelerationStructureTrianglesDisplacementMicromapNV::AccelerationStructureTrianglesDisplacementMicromapNV(
+    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;
+    }
+}
+
+AccelerationStructureTrianglesDisplacementMicromapNV::AccelerationStructureTrianglesDisplacementMicromapNV()
+    : 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() {}
+
+AccelerationStructureTrianglesDisplacementMicromapNV::AccelerationStructureTrianglesDisplacementMicromapNV(
+    const AccelerationStructureTrianglesDisplacementMicromapNV& 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;
+    }
+}
+
+AccelerationStructureTrianglesDisplacementMicromapNV& AccelerationStructureTrianglesDisplacementMicromapNV::operator=(
+    const AccelerationStructureTrianglesDisplacementMicromapNV& 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;
+}
+
+AccelerationStructureTrianglesDisplacementMicromapNV::~AccelerationStructureTrianglesDisplacementMicromapNV() {
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+}
+
+void AccelerationStructureTrianglesDisplacementMicromapNV::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 AccelerationStructureTrianglesDisplacementMicromapNV::initialize(
+    const AccelerationStructureTrianglesDisplacementMicromapNV* 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 safe
+}  // 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..3df1048
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -0,0 +1,3632 @@
+// *** 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 {
+namespace safe {
+char *SafeStringCopy(const char *in_string) {
+    if (nullptr == in_string) return nullptr;
+    char *dest = new char[std::strlen(in_string) + 1];
+    return std::strcpy(dest, in_string);
+}
+
+// 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 ShaderModuleCreateInfo(reinterpret_cast<const VkShaderModuleCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
+                safe_pNext = new PipelineLayoutCreateInfo(reinterpret_cast<const VkPipelineLayoutCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+                safe_pNext = new PhysicalDeviceSubgroupProperties(reinterpret_cast<const VkPhysicalDeviceSubgroupProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+                safe_pNext = new PhysicalDevice16BitStorageFeatures(reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+                safe_pNext = new MemoryDedicatedRequirements(reinterpret_cast<const VkMemoryDedicatedRequirements *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+                safe_pNext = new MemoryDedicatedAllocateInfo(reinterpret_cast<const VkMemoryDedicatedAllocateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+                safe_pNext = new MemoryAllocateFlagsInfo(reinterpret_cast<const VkMemoryAllocateFlagsInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+                safe_pNext = new DeviceGroupRenderPassBeginInfo(reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+                safe_pNext = new DeviceGroupCommandBufferBeginInfo(reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+                safe_pNext = new DeviceGroupSubmitInfo(reinterpret_cast<const VkDeviceGroupSubmitInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+                safe_pNext = new DeviceGroupBindSparseInfo(reinterpret_cast<const VkDeviceGroupBindSparseInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+                safe_pNext = new BindBufferMemoryDeviceGroupInfo(reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+                safe_pNext = new BindImageMemoryDeviceGroupInfo(reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+                safe_pNext = new DeviceGroupDeviceCreateInfo(reinterpret_cast<const VkDeviceGroupDeviceCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+                safe_pNext = new PhysicalDeviceFeatures2(reinterpret_cast<const VkPhysicalDeviceFeatures2 *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+                safe_pNext = new PhysicalDevicePointClippingProperties(reinterpret_cast<const VkPhysicalDevicePointClippingProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+                safe_pNext = new RenderPassInputAttachmentAspectCreateInfo(reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+                safe_pNext = new ImageViewUsageCreateInfo(reinterpret_cast<const VkImageViewUsageCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+                safe_pNext = new PipelineTessellationDomainOriginStateCreateInfo(reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+                safe_pNext = new RenderPassMultiviewCreateInfo(reinterpret_cast<const VkRenderPassMultiviewCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+                safe_pNext = new PhysicalDeviceMultiviewFeatures(reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+                safe_pNext = new PhysicalDeviceMultiviewProperties(reinterpret_cast<const VkPhysicalDeviceMultiviewProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+                safe_pNext = new PhysicalDeviceVariablePointersFeatures(reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+                safe_pNext = new PhysicalDeviceProtectedMemoryFeatures(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+                safe_pNext = new PhysicalDeviceProtectedMemoryProperties(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+                safe_pNext = new ProtectedSubmitInfo(reinterpret_cast<const VkProtectedSubmitInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+                safe_pNext = new SamplerYcbcrConversionInfo(reinterpret_cast<const VkSamplerYcbcrConversionInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+                safe_pNext = new BindImagePlaneMemoryInfo(reinterpret_cast<const VkBindImagePlaneMemoryInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+                safe_pNext = new ImagePlaneMemoryRequirementsInfo(reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+                safe_pNext = new PhysicalDeviceSamplerYcbcrConversionFeatures(reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+                safe_pNext = new SamplerYcbcrConversionImageFormatProperties(reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+                safe_pNext = new PhysicalDeviceExternalImageFormatInfo(reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+                safe_pNext = new ExternalImageFormatProperties(reinterpret_cast<const VkExternalImageFormatProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+                safe_pNext = new PhysicalDeviceIDProperties(reinterpret_cast<const VkPhysicalDeviceIDProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+                safe_pNext = new ExternalMemoryImageCreateInfo(reinterpret_cast<const VkExternalMemoryImageCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+                safe_pNext = new ExternalMemoryBufferCreateInfo(reinterpret_cast<const VkExternalMemoryBufferCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+                safe_pNext = new ExportMemoryAllocateInfo(reinterpret_cast<const VkExportMemoryAllocateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+                safe_pNext = new ExportFenceCreateInfo(reinterpret_cast<const VkExportFenceCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+                safe_pNext = new ExportSemaphoreCreateInfo(reinterpret_cast<const VkExportSemaphoreCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+                safe_pNext = new PhysicalDeviceMaintenance3Properties(reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+                safe_pNext = new PhysicalDeviceShaderDrawParametersFeatures(reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+                safe_pNext = new PhysicalDeviceVulkan11Features(reinterpret_cast<const VkPhysicalDeviceVulkan11Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
+                safe_pNext = new PhysicalDeviceVulkan11Properties(reinterpret_cast<const VkPhysicalDeviceVulkan11Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+                safe_pNext = new PhysicalDeviceVulkan12Features(reinterpret_cast<const VkPhysicalDeviceVulkan12Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
+                safe_pNext = new PhysicalDeviceVulkan12Properties(reinterpret_cast<const VkPhysicalDeviceVulkan12Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
+                safe_pNext = new ImageFormatListCreateInfo(reinterpret_cast<const VkImageFormatListCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+                safe_pNext = new PhysicalDevice8BitStorageFeatures(reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+                safe_pNext = new PhysicalDeviceDriverProperties(reinterpret_cast<const VkPhysicalDeviceDriverProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+                safe_pNext = new PhysicalDeviceShaderAtomicInt64Features(reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+                safe_pNext = new PhysicalDeviceShaderFloat16Int8Features(reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
+                safe_pNext = new PhysicalDeviceFloatControlsProperties(reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
+                safe_pNext = new DescriptorSetLayoutBindingFlagsCreateInfo(reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+                safe_pNext = new PhysicalDeviceDescriptorIndexingFeatures(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
+                safe_pNext = new PhysicalDeviceDescriptorIndexingProperties(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
+                safe_pNext = new DescriptorSetVariableDescriptorCountAllocateInfo(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+                safe_pNext = new DescriptorSetVariableDescriptorCountLayoutSupport(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
+                safe_pNext = new SubpassDescriptionDepthStencilResolve(reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
+                safe_pNext = new PhysicalDeviceDepthStencilResolveProperties(reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+                safe_pNext = new PhysicalDeviceScalarBlockLayoutFeatures(reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
+                safe_pNext = new ImageStencilUsageCreateInfo(reinterpret_cast<const VkImageStencilUsageCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
+                safe_pNext = new SamplerReductionModeCreateInfo(reinterpret_cast<const VkSamplerReductionModeCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
+                safe_pNext = new PhysicalDeviceSamplerFilterMinmaxProperties(reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+                safe_pNext = new PhysicalDeviceVulkanMemoryModelFeatures(reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+                safe_pNext = new PhysicalDeviceImagelessFramebufferFeatures(reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+                safe_pNext = new FramebufferAttachmentsCreateInfo(reinterpret_cast<const VkFramebufferAttachmentsCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
+                safe_pNext = new RenderPassAttachmentBeginInfo(reinterpret_cast<const VkRenderPassAttachmentBeginInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+                safe_pNext = new PhysicalDeviceUniformBufferStandardLayoutFeatures(reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+                safe_pNext = new PhysicalDeviceShaderSubgroupExtendedTypesFeatures(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+                safe_pNext = new PhysicalDeviceSeparateDepthStencilLayoutsFeatures(reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
+                safe_pNext = new AttachmentReferenceStencilLayout(reinterpret_cast<const VkAttachmentReferenceStencilLayout *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
+                safe_pNext = new AttachmentDescriptionStencilLayout(reinterpret_cast<const VkAttachmentDescriptionStencilLayout *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+                safe_pNext = new PhysicalDeviceHostQueryResetFeatures(reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+                safe_pNext = new PhysicalDeviceTimelineSemaphoreFeatures(reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
+                safe_pNext = new PhysicalDeviceTimelineSemaphoreProperties(reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+                safe_pNext = new SemaphoreTypeCreateInfo(reinterpret_cast<const VkSemaphoreTypeCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
+                safe_pNext = new TimelineSemaphoreSubmitInfo(reinterpret_cast<const VkTimelineSemaphoreSubmitInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+                safe_pNext = new PhysicalDeviceBufferDeviceAddressFeatures(reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
+                safe_pNext = new BufferOpaqueCaptureAddressCreateInfo(reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
+                safe_pNext = new MemoryOpaqueCaptureAddressAllocateInfo(reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
+                safe_pNext = new PhysicalDeviceVulkan13Features(reinterpret_cast<const VkPhysicalDeviceVulkan13Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
+                safe_pNext = new PhysicalDeviceVulkan13Properties(reinterpret_cast<const VkPhysicalDeviceVulkan13Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+                safe_pNext = new PipelineCreationFeedbackCreateInfo(reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
+                safe_pNext = new PhysicalDeviceShaderTerminateInvocationFeatures(reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
+                safe_pNext = new PhysicalDeviceShaderDemoteToHelperInvocationFeatures(reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
+                safe_pNext = new PhysicalDevicePrivateDataFeatures(reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
+                safe_pNext = new DevicePrivateDataCreateInfo(reinterpret_cast<const VkDevicePrivateDataCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
+                safe_pNext = new PhysicalDevicePipelineCreationCacheControlFeatures(reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
+                safe_pNext = new MemoryBarrier2(reinterpret_cast<const VkMemoryBarrier2 *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
+                safe_pNext = new PhysicalDeviceSynchronization2Features(reinterpret_cast<const VkPhysicalDeviceSynchronization2Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+                safe_pNext = new PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
+                safe_pNext = new PhysicalDeviceImageRobustnessFeatures(reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
+                safe_pNext = new PhysicalDeviceSubgroupSizeControlFeatures(reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
+                safe_pNext = new PhysicalDeviceSubgroupSizeControlProperties(reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
+                safe_pNext = new PipelineShaderStageRequiredSubgroupSizeCreateInfo(reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
+                safe_pNext = new PhysicalDeviceInlineUniformBlockFeatures(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
+                safe_pNext = new PhysicalDeviceInlineUniformBlockProperties(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
+                safe_pNext = new WriteDescriptorSetInlineUniformBlock(reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
+                safe_pNext = new DescriptorPoolInlineUniformBlockCreateInfo(reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
+                safe_pNext = new PhysicalDeviceTextureCompressionASTCHDRFeatures(reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
+                safe_pNext = new PipelineRenderingCreateInfo(reinterpret_cast<const VkPipelineRenderingCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
+                safe_pNext = new PhysicalDeviceDynamicRenderingFeatures(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
+                safe_pNext = new CommandBufferInheritanceRenderingInfo(reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
+                safe_pNext = new PhysicalDeviceShaderIntegerDotProductFeatures(reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
+                safe_pNext = new PhysicalDeviceShaderIntegerDotProductProperties(reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
+                safe_pNext = new PhysicalDeviceTexelBufferAlignmentProperties(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
+                safe_pNext = new FormatProperties3(reinterpret_cast<const VkFormatProperties3 *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
+                safe_pNext = new PhysicalDeviceMaintenance4Features(reinterpret_cast<const VkPhysicalDeviceMaintenance4Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
+                safe_pNext = new PhysicalDeviceMaintenance4Properties(reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+                safe_pNext = new ImageSwapchainCreateInfoKHR(reinterpret_cast<const VkImageSwapchainCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+                safe_pNext = new BindImageMemorySwapchainInfoKHR(reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+                safe_pNext = new DeviceGroupPresentInfoKHR(reinterpret_cast<const VkDeviceGroupPresentInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+                safe_pNext = new DeviceGroupSwapchainCreateInfoKHR(reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+                safe_pNext = new DisplayPresentInfoKHR(reinterpret_cast<const VkDisplayPresentInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
+                safe_pNext = new QueueFamilyQueryResultStatusPropertiesKHR(reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
+                safe_pNext = new QueueFamilyVideoPropertiesKHR(reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
+                safe_pNext = new VideoProfileInfoKHR(reinterpret_cast<const VkVideoProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
+                safe_pNext = new VideoProfileListInfoKHR(reinterpret_cast<const VkVideoProfileListInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
+                safe_pNext = new VideoDecodeCapabilitiesKHR(reinterpret_cast<const VkVideoDecodeCapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
+                safe_pNext = new VideoDecodeUsageInfoKHR(reinterpret_cast<const VkVideoDecodeUsageInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR:
+                safe_pNext = new VideoEncodeH264CapabilitiesKHR(reinterpret_cast<const VkVideoEncodeH264CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
+                safe_pNext = new VideoEncodeH264QualityLevelPropertiesKHR(reinterpret_cast<const VkVideoEncodeH264QualityLevelPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
+                safe_pNext = new VideoEncodeH264SessionCreateInfoKHR(reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
+                safe_pNext = new VideoEncodeH264SessionParametersAddInfoKHR(reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new VideoEncodeH264SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR:
+                safe_pNext = new VideoEncodeH264SessionParametersGetInfoKHR(reinterpret_cast<const VkVideoEncodeH264SessionParametersGetInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
+                safe_pNext = new VideoEncodeH264SessionParametersFeedbackInfoKHR(reinterpret_cast<const VkVideoEncodeH264SessionParametersFeedbackInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR:
+                safe_pNext = new VideoEncodeH264PictureInfoKHR(reinterpret_cast<const VkVideoEncodeH264PictureInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
+                safe_pNext = new VideoEncodeH264DpbSlotInfoKHR(reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
+                safe_pNext = new VideoEncodeH264ProfileInfoKHR(reinterpret_cast<const VkVideoEncodeH264ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
+                safe_pNext = new VideoEncodeH264RateControlInfoKHR(reinterpret_cast<const VkVideoEncodeH264RateControlInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
+                safe_pNext = new VideoEncodeH264RateControlLayerInfoKHR(reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR:
+                safe_pNext = new VideoEncodeH264GopRemainingFrameInfoKHR(reinterpret_cast<const VkVideoEncodeH264GopRemainingFrameInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR:
+                safe_pNext = new VideoEncodeH265CapabilitiesKHR(reinterpret_cast<const VkVideoEncodeH265CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR:
+                safe_pNext = new VideoEncodeH265SessionCreateInfoKHR(reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR:
+                safe_pNext = new VideoEncodeH265QualityLevelPropertiesKHR(reinterpret_cast<const VkVideoEncodeH265QualityLevelPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
+                safe_pNext = new VideoEncodeH265SessionParametersAddInfoKHR(reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new VideoEncodeH265SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR:
+                safe_pNext = new VideoEncodeH265SessionParametersGetInfoKHR(reinterpret_cast<const VkVideoEncodeH265SessionParametersGetInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
+                safe_pNext = new VideoEncodeH265SessionParametersFeedbackInfoKHR(reinterpret_cast<const VkVideoEncodeH265SessionParametersFeedbackInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR:
+                safe_pNext = new VideoEncodeH265PictureInfoKHR(reinterpret_cast<const VkVideoEncodeH265PictureInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR:
+                safe_pNext = new VideoEncodeH265DpbSlotInfoKHR(reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR:
+                safe_pNext = new VideoEncodeH265ProfileInfoKHR(reinterpret_cast<const VkVideoEncodeH265ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR:
+                safe_pNext = new VideoEncodeH265RateControlInfoKHR(reinterpret_cast<const VkVideoEncodeH265RateControlInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR:
+                safe_pNext = new VideoEncodeH265RateControlLayerInfoKHR(reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR:
+                safe_pNext = new VideoEncodeH265GopRemainingFrameInfoKHR(reinterpret_cast<const VkVideoEncodeH265GopRemainingFrameInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR:
+                safe_pNext = new VideoDecodeH264ProfileInfoKHR(reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR:
+                safe_pNext = new VideoDecodeH264CapabilitiesKHR(reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
+                safe_pNext = new VideoDecodeH264SessionParametersAddInfoKHR(reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new VideoDecodeH264SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR:
+                safe_pNext = new VideoDecodeH264PictureInfoKHR(reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
+                safe_pNext = new VideoDecodeH264DpbSlotInfoKHR(reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+                safe_pNext = new RenderingFragmentShadingRateAttachmentInfoKHR(reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
+                safe_pNext = new RenderingFragmentDensityMapAttachmentInfoEXT(reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+                safe_pNext = new AttachmentSampleCountInfoAMD(reinterpret_cast<const VkAttachmentSampleCountInfoAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
+                safe_pNext = new MultiviewPerViewAttributesInfoNVX(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 ImportMemoryWin32HandleInfoKHR(reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+                safe_pNext = new ExportMemoryWin32HandleInfoKHR(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 ImportMemoryFdInfoKHR(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 Win32KeyedMutexAcquireReleaseInfoKHR(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+                safe_pNext = new ExportSemaphoreWin32HandleInfoKHR(reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+                safe_pNext = new D3D12FenceSubmitInfoKHR(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 PhysicalDevicePushDescriptorPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+                safe_pNext = new PresentRegionsKHR(reinterpret_cast<const VkPresentRegionsKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+                safe_pNext = new SharedPresentSurfaceCapabilitiesKHR(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 ExportFenceWin32HandleInfoKHR(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 PhysicalDevicePerformanceQueryFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
+                safe_pNext = new PhysicalDevicePerformanceQueryPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
+                safe_pNext = new QueryPoolPerformanceCreateInfoKHR(reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
+                safe_pNext = new PerformanceQuerySubmitInfoKHR(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 PhysicalDevicePortabilitySubsetFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
+                safe_pNext = new PhysicalDevicePortabilitySubsetPropertiesKHR(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 PhysicalDeviceShaderClockFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR:
+                safe_pNext = new VideoDecodeH265ProfileInfoKHR(reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR:
+                safe_pNext = new VideoDecodeH265CapabilitiesKHR(reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
+                safe_pNext = new VideoDecodeH265SessionParametersAddInfoKHR(reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new VideoDecodeH265SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR:
+                safe_pNext = new VideoDecodeH265PictureInfoKHR(reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
+                safe_pNext = new VideoDecodeH265DpbSlotInfoKHR(reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
+                safe_pNext = new DeviceQueueGlobalPriorityCreateInfoKHR(reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceGlobalPriorityQueryFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
+                safe_pNext = new QueueFamilyGlobalPriorityPropertiesKHR(reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+                safe_pNext = new FragmentShadingRateAttachmentInfoKHR(reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
+                safe_pNext = new PipelineFragmentShadingRateStateCreateInfoKHR(reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceFragmentShadingRateFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
+                safe_pNext = new PhysicalDeviceFragmentShadingRatePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR:
+                safe_pNext = new RenderingAttachmentLocationInfoKHR(reinterpret_cast<const VkRenderingAttachmentLocationInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR:
+                safe_pNext = new RenderingInputAttachmentIndexInfoKHR(reinterpret_cast<const VkRenderingInputAttachmentIndexInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceShaderQuadControlFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
+                safe_pNext = new SurfaceProtectedCapabilitiesKHR(reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
+                safe_pNext = new PhysicalDevicePresentWaitFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+                safe_pNext = new PhysicalDevicePipelineExecutablePropertiesFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
+                safe_pNext = new PipelineLibraryCreateInfoKHR(reinterpret_cast<const VkPipelineLibraryCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
+                safe_pNext = new PresentIdKHR(reinterpret_cast<const VkPresentIdKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
+                safe_pNext = new PhysicalDevicePresentIdFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
+                safe_pNext = new VideoEncodeCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
+                safe_pNext = new QueryPoolVideoEncodeFeedbackCreateInfoKHR(reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
+                safe_pNext = new VideoEncodeUsageInfoKHR(reinterpret_cast<const VkVideoEncodeUsageInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
+                safe_pNext = new VideoEncodeRateControlInfoKHR(reinterpret_cast<const VkVideoEncodeRateControlInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
+                safe_pNext = new VideoEncodeQualityLevelInfoKHR(reinterpret_cast<const VkVideoEncodeQualityLevelInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
+                safe_pNext = new QueueFamilyCheckpointProperties2NV(reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceFragmentShaderBarycentricFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
+                safe_pNext = new PhysicalDeviceFragmentShaderBarycentricPropertiesKHR(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 PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceRayTracingMaintenance1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceShaderSubgroupRotateFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceMaintenance5FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance5FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
+                safe_pNext = new PhysicalDeviceMaintenance5PropertiesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance5PropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
+                safe_pNext = new PipelineCreateFlags2CreateInfoKHR(reinterpret_cast<const VkPipelineCreateFlags2CreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
+                safe_pNext = new BufferUsageFlags2CreateInfoKHR(reinterpret_cast<const VkBufferUsageFlags2CreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceCooperativeMatrixFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
+                safe_pNext = new PhysicalDeviceCooperativeMatrixPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
+                safe_pNext = new VideoDecodeAV1ProfileInfoKHR(reinterpret_cast<const VkVideoDecodeAV1ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
+                safe_pNext = new VideoDecodeAV1CapabilitiesKHR(reinterpret_cast<const VkVideoDecodeAV1CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new VideoDecodeAV1SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoDecodeAV1SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
+                safe_pNext = new VideoDecodeAV1PictureInfoKHR(reinterpret_cast<const VkVideoDecodeAV1PictureInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
+                safe_pNext = new VideoDecodeAV1DpbSlotInfoKHR(reinterpret_cast<const VkVideoDecodeAV1DpbSlotInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceVideoMaintenance1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
+                safe_pNext = new VideoInlineQueryInfoKHR(reinterpret_cast<const VkVideoInlineQueryInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR:
+                safe_pNext = new PhysicalDeviceVertexAttributeDivisorPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR:
+                safe_pNext = new PipelineVertexInputDivisorStateCreateInfoKHR(reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceVertexAttributeDivisorFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceShaderFloatControls2FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceIndexTypeUint8FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceLineRasterizationFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR:
+                safe_pNext = new PhysicalDeviceLineRasterizationPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR:
+                safe_pNext = new PipelineRasterizationLineStateCreateInfoKHR(reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceShaderExpectAssumeFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceMaintenance6FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance6FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR:
+                safe_pNext = new PhysicalDeviceMaintenance6PropertiesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance6PropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
+                safe_pNext = new BindMemoryStatusKHR(reinterpret_cast<const VkBindMemoryStatusKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+                safe_pNext = new DebugReportCallbackCreateInfoEXT(reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+                safe_pNext = new PipelineRasterizationStateRasterizationOrderAMD(reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+                safe_pNext = new DedicatedAllocationImageCreateInfoNV(reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+                safe_pNext = new DedicatedAllocationBufferCreateInfoNV(reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+                safe_pNext = new DedicatedAllocationMemoryAllocateInfoNV(reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceTransformFeedbackFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceTransformFeedbackPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
+                safe_pNext = new PipelineRasterizationStateStreamCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+                safe_pNext = new TextureLODGatherFormatPropertiesAMD(reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceCornerSampledImageFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+                safe_pNext = new ExternalMemoryImageCreateInfoNV(reinterpret_cast<const VkExternalMemoryImageCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+                safe_pNext = new ExportMemoryAllocateInfoNV(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 ImportMemoryWin32HandleInfoNV(reinterpret_cast<const VkImportMemoryWin32HandleInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+                safe_pNext = new ExportMemoryWin32HandleInfoNV(reinterpret_cast<const VkExportMemoryWin32HandleInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+                safe_pNext = new Win32KeyedMutexAcquireReleaseInfoNV(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 ValidationFlagsEXT(reinterpret_cast<const VkValidationFlagsEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
+                safe_pNext = new ImageViewASTCDecodeModeEXT(reinterpret_cast<const VkImageViewASTCDecodeModeEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceASTCDecodeFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
+                safe_pNext = new PhysicalDevicePipelineRobustnessFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDevicePipelineRobustnessPropertiesEXT(reinterpret_cast<const VkPhysicalDevicePipelineRobustnessPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
+                safe_pNext = new PipelineRobustnessCreateInfoEXT(reinterpret_cast<const VkPipelineRobustnessCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceConditionalRenderingFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+                safe_pNext = new CommandBufferInheritanceConditionalRenderingInfoEXT(reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+                safe_pNext = new PipelineViewportWScalingStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+                safe_pNext = new SwapchainCounterCreateInfoEXT(reinterpret_cast<const VkSwapchainCounterCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+                safe_pNext = new PresentTimesInfoGOOGLE(reinterpret_cast<const VkPresentTimesInfoGOOGLE *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+                safe_pNext = new PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+                safe_pNext = new PipelineViewportSwizzleStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceDiscardRectanglePropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+                safe_pNext = new PipelineDiscardRectangleStateCreateInfoEXT(reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceConservativeRasterizationPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+                safe_pNext = new PipelineRasterizationConservativeStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceDepthClipEnableFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
+                safe_pNext = new PipelineRasterizationDepthClipStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
+                safe_pNext = new PhysicalDeviceRelaxedLineRasterizationFeaturesIMG(reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
+                safe_pNext = new DebugUtilsObjectNameInfoEXT(reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+                safe_pNext = new DebugUtilsMessengerCreateInfoEXT(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 AndroidHardwareBufferUsageANDROID(reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+                safe_pNext = new AndroidHardwareBufferFormatPropertiesANDROID(reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+                safe_pNext = new ImportAndroidHardwareBufferInfoANDROID(reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+                safe_pNext = new ExternalFormatANDROID(reinterpret_cast<const VkExternalFormatANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
+                safe_pNext = new AndroidHardwareBufferFormatProperties2ANDROID(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 PhysicalDeviceShaderEnqueueFeaturesAMDX(reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
+                safe_pNext = new PhysicalDeviceShaderEnqueuePropertiesAMDX(reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
+                safe_pNext = new PipelineShaderStageNodeCreateInfoAMDX(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 SampleLocationsInfoEXT(reinterpret_cast<const VkSampleLocationsInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+                safe_pNext = new RenderPassSampleLocationsBeginInfoEXT(reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+                safe_pNext = new PipelineSampleLocationsStateCreateInfoEXT(reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceSampleLocationsPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceBlendOperationAdvancedFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceBlendOperationAdvancedPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+                safe_pNext = new PipelineColorBlendAdvancedStateCreateInfoEXT(reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+                safe_pNext = new PipelineCoverageToColorStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+                safe_pNext = new PipelineCoverageModulationStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceShaderSMBuiltinsPropertiesNV(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceShaderSMBuiltinsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
+                safe_pNext = new DrmFormatModifierPropertiesListEXT(reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
+                safe_pNext = new PhysicalDeviceImageDrmFormatModifierInfoEXT(reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
+                safe_pNext = new ImageDrmFormatModifierListCreateInfoEXT(reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
+                safe_pNext = new ImageDrmFormatModifierExplicitCreateInfoEXT(reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
+                safe_pNext = new DrmFormatModifierPropertiesList2EXT(reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+                safe_pNext = new ShaderModuleValidationCacheCreateInfoEXT(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 PipelineViewportShadingRateImageStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceShadingRateImageFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceShadingRateImagePropertiesNV(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 PipelineViewportCoarseSampleOrderStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
+                safe_pNext = new WriteDescriptorSetAccelerationStructureNV(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceRayTracingPropertiesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceRepresentativeFragmentTestFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
+                safe_pNext = new PipelineRepresentativeFragmentTestStateCreateInfoNV(reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
+                safe_pNext = new PhysicalDeviceImageViewImageFormatInfoEXT(reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
+                safe_pNext = new FilterCubicImageViewImageFormatPropertiesEXT(reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+                safe_pNext = new ImportMemoryHostPointerInfoEXT(reinterpret_cast<const VkImportMemoryHostPointerInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceExternalMemoryHostPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+                safe_pNext = new PipelineCompilerControlCreateInfoAMD(reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+                safe_pNext = new PhysicalDeviceShaderCorePropertiesAMD(reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
+                safe_pNext = new DeviceMemoryOverallocationCreateInfoAMD(reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceVertexAttributeDivisorPropertiesEXT(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 PresentFrameTokenGGP(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 PhysicalDeviceComputeShaderDerivativesFeaturesNV(reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceMeshShaderFeaturesNV(reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceMeshShaderPropertiesNV(reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceShaderImageFootprintFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
+                safe_pNext = new PipelineViewportExclusiveScissorStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceExclusiveScissorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+                safe_pNext = new QueueFamilyCheckpointPropertiesNV(reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+                safe_pNext = new PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
+                safe_pNext = new QueryPoolPerformanceQueryCreateInfoINTEL(reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDevicePCIBusInfoPropertiesEXT(reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
+                safe_pNext = new DisplayNativeHdrSurfaceCapabilitiesAMD(reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
+                safe_pNext = new SwapchainDisplayNativeHdrCreateInfoAMD(reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceFragmentDensityMapFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceFragmentDensityMapPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
+                safe_pNext = new RenderPassFragmentDensityMapCreateInfoEXT(reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
+                safe_pNext = new PhysicalDeviceShaderCoreProperties2AMD(reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+                safe_pNext = new PhysicalDeviceCoherentMemoryFeaturesAMD(reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceShaderImageAtomicInt64FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceMemoryBudgetPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceMemoryPriorityFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
+                safe_pNext = new MemoryPriorityAllocateInfoEXT(reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceBufferDeviceAddressFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
+                safe_pNext = new BufferDeviceAddressCreateInfoEXT(reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
+                safe_pNext = new ValidationFeaturesEXT(reinterpret_cast<const VkValidationFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceCooperativeMatrixFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceCooperativeMatrixPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceCoverageReductionModeFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
+                safe_pNext = new PipelineCoverageReductionStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceFragmentShaderInterlockFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceYcbcrImageArraysFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceProvokingVertexFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceProvokingVertexPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
+                safe_pNext = new PipelineRasterizationProvokingVertexStateCreateInfoEXT(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 SurfaceFullScreenExclusiveInfoEXT(reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
+                safe_pNext = new SurfaceCapabilitiesFullScreenExclusiveEXT(reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
+                safe_pNext = new SurfaceFullScreenExclusiveWin32InfoEXT(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 PhysicalDeviceShaderAtomicFloatFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceExtendedDynamicStateFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceHostImageCopyFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceHostImageCopyPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceHostImageCopyPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
+                safe_pNext = new SubresourceHostMemcpySizeEXT(reinterpret_cast<const VkSubresourceHostMemcpySizeEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
+                safe_pNext = new HostImageCopyDevicePerformanceQueryEXT(reinterpret_cast<const VkHostImageCopyDevicePerformanceQueryEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceMapMemoryPlacedFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceMapMemoryPlacedPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
+                safe_pNext = new MemoryMapPlacedInfoEXT(reinterpret_cast<const VkMemoryMapPlacedInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceShaderAtomicFloat2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
+                safe_pNext = new SurfacePresentModeEXT(reinterpret_cast<const VkSurfacePresentModeEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
+                safe_pNext = new SurfacePresentScalingCapabilitiesEXT(reinterpret_cast<const VkSurfacePresentScalingCapabilitiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
+                safe_pNext = new SurfacePresentModeCompatibilityEXT(reinterpret_cast<const VkSurfacePresentModeCompatibilityEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceSwapchainMaintenance1FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
+                safe_pNext = new SwapchainPresentFenceInfoEXT(reinterpret_cast<const VkSwapchainPresentFenceInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
+                safe_pNext = new SwapchainPresentModesCreateInfoEXT(reinterpret_cast<const VkSwapchainPresentModesCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
+                safe_pNext = new SwapchainPresentModeInfoEXT(reinterpret_cast<const VkSwapchainPresentModeInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
+                safe_pNext = new SwapchainPresentScalingCreateInfoEXT(reinterpret_cast<const VkSwapchainPresentScalingCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceDeviceGeneratedCommandsPropertiesNV(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceDeviceGeneratedCommandsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
+                safe_pNext = new GraphicsPipelineShaderGroupsCreateInfoNV(reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceInheritedViewportScissorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
+                safe_pNext = new CommandBufferInheritanceViewportScissorInfoNV(reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceTexelBufferAlignmentFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
+                safe_pNext = new RenderPassTransformBeginInfoQCOM(reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
+                safe_pNext = new CommandBufferInheritanceRenderPassTransformInfoQCOM(reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceDepthBiasControlFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
+                safe_pNext = new DepthBiasRepresentationInfoEXT(reinterpret_cast<const VkDepthBiasRepresentationInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceDeviceMemoryReportFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
+                safe_pNext = new DeviceDeviceMemoryReportCreateInfoEXT(reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceRobustness2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceRobustness2PropertiesEXT(reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
+                safe_pNext = new SamplerCustomBorderColorCreateInfoEXT(reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceCustomBorderColorPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceCustomBorderColorFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
+                safe_pNext = new PhysicalDevicePresentBarrierFeaturesNV(reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
+                safe_pNext = new SurfaceCapabilitiesPresentBarrierNV(reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
+                safe_pNext = new SwapchainPresentBarrierCreateInfoNV(reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceDiagnosticsConfigFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
+                safe_pNext = new DeviceDiagnosticsConfigCreateInfoNV(reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceCudaKernelLaunchFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceCudaKernelLaunchPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
+                safe_pNext = new QueryLowLatencySupportNV(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 ExportMetalObjectCreateInfoEXT(reinterpret_cast<const VkExportMetalObjectCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
+                safe_pNext = new ExportMetalDeviceInfoEXT(reinterpret_cast<const VkExportMetalDeviceInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
+                safe_pNext = new ExportMetalCommandQueueInfoEXT(reinterpret_cast<const VkExportMetalCommandQueueInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
+                safe_pNext = new ExportMetalBufferInfoEXT(reinterpret_cast<const VkExportMetalBufferInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
+                safe_pNext = new ImportMetalBufferInfoEXT(reinterpret_cast<const VkImportMetalBufferInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
+                safe_pNext = new ExportMetalTextureInfoEXT(reinterpret_cast<const VkExportMetalTextureInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
+                safe_pNext = new ImportMetalTextureInfoEXT(reinterpret_cast<const VkImportMetalTextureInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
+                safe_pNext = new ExportMetalIOSurfaceInfoEXT(reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
+                safe_pNext = new ImportMetalIOSurfaceInfoEXT(reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
+                safe_pNext = new ExportMetalSharedEventInfoEXT(reinterpret_cast<const VkExportMetalSharedEventInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
+                safe_pNext = new ImportMetalSharedEventInfoEXT(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 PhysicalDeviceDescriptorBufferPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceDescriptorBufferFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
+                safe_pNext = new DescriptorBufferBindingPushDescriptorBufferHandleEXT(reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
+                safe_pNext = new OpaqueCaptureDescriptorDataCreateInfoEXT(reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
+                safe_pNext = new GraphicsPipelineLibraryCreateInfoEXT(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 PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceFragmentShadingRateEnumsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceFragmentShadingRateEnumsPropertiesNV(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 PipelineFragmentShadingRateEnumStateCreateInfoNV(reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
+                safe_pNext = new AccelerationStructureGeometryMotionTrianglesDataNV(reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
+                safe_pNext = new AccelerationStructureMotionInfoNV(reinterpret_cast<const VkAccelerationStructureMotionInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceRayTracingMotionBlurFeaturesNV(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 PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceFragmentDensityMap2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceFragmentDensityMap2PropertiesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
+                safe_pNext = new CopyCommandTransformInfoQCOM(reinterpret_cast<const VkCopyCommandTransformInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceImageCompressionControlFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
+                safe_pNext = new ImageCompressionControlEXT(reinterpret_cast<const VkImageCompressionControlEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
+                safe_pNext = new ImageCompressionPropertiesEXT(reinterpret_cast<const VkImageCompressionPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
+                safe_pNext = new PhysicalDevice4444FormatsFeaturesEXT(reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceFaultFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceRGBA10X6FormatsFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceMutableDescriptorTypeFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
+                safe_pNext = new MutableDescriptorTypeCreateInfoEXT(reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceVertexInputDynamicStateFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceDrmPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceAddressBindingReportFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
+                safe_pNext = new DeviceAddressBindingCallbackDataEXT(reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceDepthClipControlFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
+                safe_pNext = new PipelineViewportDepthClipControlCreateInfoEXT(reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
+                safe_pNext = new PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(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 ImportMemoryZirconHandleInfoFUCHSIA(reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
+                safe_pNext = new ImportMemoryBufferCollectionFUCHSIA(reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
+                safe_pNext = new BufferCollectionImageCreateInfoFUCHSIA(reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
+                safe_pNext = new BufferCollectionBufferCreateInfoFUCHSIA(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 SubpassShadingPipelineCreateInfoHUAWEI(reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
+                safe_pNext = new PhysicalDeviceSubpassShadingFeaturesHUAWEI(reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
+                safe_pNext = new PhysicalDeviceSubpassShadingPropertiesHUAWEI(reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
+                safe_pNext = new PhysicalDeviceInvocationMaskFeaturesHUAWEI(reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceExternalMemoryRDMAFeaturesNV(reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
+                safe_pNext = new PhysicalDevicePipelinePropertiesFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceFrameBoundaryFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
+                safe_pNext = new FrameBoundaryEXT(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 PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
+                safe_pNext = new SubpassResolvePerformanceQueryEXT(reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
+                safe_pNext = new MultisampledRenderToSingleSampledInfoEXT(reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceExtendedDynamicState2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceColorWriteEnableFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
+                safe_pNext = new PipelineColorWriteCreateInfoEXT(reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
+                safe_pNext = new PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceImageViewMinLodFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
+                safe_pNext = new ImageViewMinLodCreateInfoEXT(reinterpret_cast<const VkImageViewMinLodCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceMultiDrawFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceMultiDrawPropertiesEXT(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 PhysicalDeviceImage2DViewOf3DFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceShaderTileImageFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceShaderTileImagePropertiesEXT(reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceOpacityMicromapFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceOpacityMicromapPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
+                safe_pNext = new AccelerationStructureTrianglesOpacityMicromapEXT(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 PhysicalDeviceDisplacementMicromapFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceDisplacementMicromapPropertiesNV(reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
+                safe_pNext = new AccelerationStructureTrianglesDisplacementMicromapNV(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 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI(reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
+                safe_pNext = new PhysicalDeviceClusterCullingShaderPropertiesHUAWEI(reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI:
+                safe_pNext = new PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceBorderColorSwizzleFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
+                safe_pNext = new SamplerBorderColorComponentMappingCreateInfoEXT(reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
+                safe_pNext = new PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
+                safe_pNext = new PhysicalDeviceShaderCorePropertiesARM(reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
+                safe_pNext = new DeviceQueueShaderCoreControlCreateInfoARM(reinterpret_cast<const VkDeviceQueueShaderCoreControlCreateInfoARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
+                safe_pNext = new PhysicalDeviceSchedulingControlsFeaturesARM(reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
+                safe_pNext = new PhysicalDeviceSchedulingControlsPropertiesARM(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 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
+                safe_pNext = new ImageViewSlicedCreateInfoEXT(reinterpret_cast<const VkImageViewSlicedCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
+                safe_pNext = new PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceDepthClampZeroOneFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceNonSeamlessCubeMapFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
+                safe_pNext = new PhysicalDeviceRenderPassStripedFeaturesARM(reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
+                safe_pNext = new PhysicalDeviceRenderPassStripedPropertiesARM(reinterpret_cast<const VkPhysicalDeviceRenderPassStripedPropertiesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
+                safe_pNext = new RenderPassStripeBeginInfoARM(reinterpret_cast<const VkRenderPassStripeBeginInfoARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
+                safe_pNext = new RenderPassStripeSubmitInfoARM(reinterpret_cast<const VkRenderPassStripeSubmitInfoARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
+                safe_pNext = new PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
+                safe_pNext = new PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
+                safe_pNext = new SubpassFragmentDensityMapOffsetEndInfoQCOM(reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceCopyMemoryIndirectFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceCopyMemoryIndirectPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceMemoryDecompressionFeaturesNV(reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceMemoryDecompressionPropertiesNV(reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
+                safe_pNext = new ComputePipelineIndirectBufferInfoNV(reinterpret_cast<const VkComputePipelineIndirectBufferInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceLinearColorAttachmentFeaturesNV(reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
+                safe_pNext = new ImageViewSampleWeightCreateInfoQCOM(reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
+                safe_pNext = new PhysicalDeviceImageProcessingFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
+                safe_pNext = new PhysicalDeviceImageProcessingPropertiesQCOM(reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceNestedCommandBufferFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceNestedCommandBufferPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
+                safe_pNext = new ExternalMemoryAcquireUnmodifiedEXT(reinterpret_cast<const VkExternalMemoryAcquireUnmodifiedEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceExtendedDynamicState3FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceExtendedDynamicState3PropertiesEXT(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceSubpassMergeFeedbackFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
+                safe_pNext = new RenderPassCreationControlEXT(reinterpret_cast<const VkRenderPassCreationControlEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
+                safe_pNext = new RenderPassCreationFeedbackCreateInfoEXT(reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
+                safe_pNext = new RenderPassSubpassFeedbackCreateInfoEXT(reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
+                safe_pNext = new DirectDriverLoadingListLUNARG(reinterpret_cast<const VkDirectDriverLoadingListLUNARG *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceShaderModuleIdentifierFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceShaderModuleIdentifierPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
+                safe_pNext = new PipelineShaderStageModuleIdentifierCreateInfoEXT(reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceOpticalFlowFeaturesNV(reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceOpticalFlowPropertiesNV(reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
+                safe_pNext = new OpticalFlowImageFormatInfoNV(reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
+                safe_pNext = new OpticalFlowSessionCreatePrivateDataInfoNV(reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceLegacyDitheringFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
+                safe_pNext = new PhysicalDevicePipelineProtectedAccessFeaturesEXT(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 PhysicalDeviceExternalFormatResolveFeaturesANDROID(reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
+                safe_pNext = new PhysicalDeviceExternalFormatResolvePropertiesANDROID(reinterpret_cast<const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
+                safe_pNext = new AndroidHardwareBufferFormatResolvePropertiesANDROID(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 PhysicalDeviceShaderObjectFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceShaderObjectPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
+                safe_pNext = new PhysicalDeviceTilePropertiesFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC:
+                safe_pNext = new PhysicalDeviceAmigoProfilingFeaturesSEC(reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
+                safe_pNext = new AmigoProfilingSubmitInfoSEC(reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
+                safe_pNext = new PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceRayTracingInvocationReorderPropertiesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceRayTracingInvocationReorderFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
+                safe_pNext = new PhysicalDeviceExtendedSparseAddressSpacePropertiesNV(reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
+                safe_pNext = new LayerSettingsCreateInfoEXT(reinterpret_cast<const VkLayerSettingsCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
+                safe_pNext = new PhysicalDeviceShaderCoreBuiltinsFeaturesARM(reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
+                safe_pNext = new PhysicalDeviceShaderCoreBuiltinsPropertiesARM(reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
+                safe_pNext = new PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
+                safe_pNext = new LatencySubmissionPresentIdNV(reinterpret_cast<const VkLatencySubmissionPresentIdNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
+                safe_pNext = new SwapchainLatencyCreateInfoNV(reinterpret_cast<const VkSwapchainLatencyCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
+                safe_pNext = new LatencySurfaceCapabilitiesNV(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 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(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 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
+                safe_pNext = new PhysicalDevicePerStageDescriptorSetFeaturesNV(reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
+                safe_pNext = new PhysicalDeviceImageProcessing2FeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
+                safe_pNext = new PhysicalDeviceImageProcessing2PropertiesQCOM(reinterpret_cast<const VkPhysicalDeviceImageProcessing2PropertiesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
+                safe_pNext = new SamplerBlockMatchWindowCreateInfoQCOM(reinterpret_cast<const VkSamplerBlockMatchWindowCreateInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
+                safe_pNext = new PhysicalDeviceCubicWeightsFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
+                safe_pNext = new SamplerCubicWeightsCreateInfoQCOM(reinterpret_cast<const VkSamplerCubicWeightsCreateInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM:
+                safe_pNext = new BlitImageCubicWeightsInfoQCOM(reinterpret_cast<const VkBlitImageCubicWeightsInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
+                safe_pNext = new PhysicalDeviceYcbcrDegammaFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM:
+                safe_pNext = new SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(reinterpret_cast<const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
+                safe_pNext = new PhysicalDeviceCubicClampFeaturesQCOM(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 PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(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 ScreenBufferFormatPropertiesQNX(reinterpret_cast<const VkScreenBufferFormatPropertiesQNX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX:
+                safe_pNext = new ImportScreenBufferInfoQNX(reinterpret_cast<const VkImportScreenBufferInfoQNX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX:
+                safe_pNext = new ExternalFormatQNX(reinterpret_cast<const VkExternalFormatQNX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX:
+                safe_pNext = new PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(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 PhysicalDeviceLayeredDriverPropertiesMSFT(reinterpret_cast<const VkPhysicalDeviceLayeredDriverPropertiesMSFT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceDescriptorPoolOverallocationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceRawAccessChainsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
+                safe_pNext = new PhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
+                safe_pNext = new WriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceAccelerationStructureFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
+                safe_pNext = new PhysicalDeviceAccelerationStructurePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceRayTracingPipelineFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
+                safe_pNext = new PhysicalDeviceRayTracingPipelinePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
+                safe_pNext = new PhysicalDeviceRayQueryFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
+                safe_pNext = new PhysicalDeviceMeshShaderFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
+                safe_pNext = new PhysicalDeviceMeshShaderPropertiesEXT(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 == 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 ShaderModuleCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
+            delete reinterpret_cast<const PipelineLayoutCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceSubgroupProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+            delete reinterpret_cast<const PhysicalDevice16BitStorageFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+            delete reinterpret_cast<const MemoryDedicatedRequirements *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+            delete reinterpret_cast<const MemoryDedicatedAllocateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+            delete reinterpret_cast<const MemoryAllocateFlagsInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+            delete reinterpret_cast<const DeviceGroupRenderPassBeginInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+            delete reinterpret_cast<const DeviceGroupCommandBufferBeginInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+            delete reinterpret_cast<const DeviceGroupSubmitInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+            delete reinterpret_cast<const DeviceGroupBindSparseInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+            delete reinterpret_cast<const BindBufferMemoryDeviceGroupInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+            delete reinterpret_cast<const BindImageMemoryDeviceGroupInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+            delete reinterpret_cast<const DeviceGroupDeviceCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+            delete reinterpret_cast<const PhysicalDeviceFeatures2 *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDevicePointClippingProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+            delete reinterpret_cast<const RenderPassInputAttachmentAspectCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+            delete reinterpret_cast<const ImageViewUsageCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+            delete reinterpret_cast<const PipelineTessellationDomainOriginStateCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+            delete reinterpret_cast<const RenderPassMultiviewCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceMultiviewFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceMultiviewProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceVariablePointersFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceProtectedMemoryFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceProtectedMemoryProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+            delete reinterpret_cast<const ProtectedSubmitInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            delete reinterpret_cast<const SamplerYcbcrConversionInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+            delete reinterpret_cast<const BindImagePlaneMemoryInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+            delete reinterpret_cast<const ImagePlaneMemoryRequirementsInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceSamplerYcbcrConversionFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+            delete reinterpret_cast<const SamplerYcbcrConversionImageFormatProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+            delete reinterpret_cast<const PhysicalDeviceExternalImageFormatInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+            delete reinterpret_cast<const ExternalImageFormatProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceIDProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+            delete reinterpret_cast<const ExternalMemoryImageCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+            delete reinterpret_cast<const ExternalMemoryBufferCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+            delete reinterpret_cast<const ExportMemoryAllocateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+            delete reinterpret_cast<const ExportFenceCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+            delete reinterpret_cast<const ExportSemaphoreCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceMaintenance3Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceShaderDrawParametersFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceVulkan11Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceVulkan11Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceVulkan12Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceVulkan12Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
+            delete reinterpret_cast<const ImageFormatListCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+            delete reinterpret_cast<const PhysicalDevice8BitStorageFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceDriverProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceShaderAtomicInt64Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceShaderFloat16Int8Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceFloatControlsProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
+            delete reinterpret_cast<const DescriptorSetLayoutBindingFlagsCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceDescriptorIndexingFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceDescriptorIndexingProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
+            delete reinterpret_cast<const DescriptorSetVariableDescriptorCountAllocateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+            delete reinterpret_cast<const DescriptorSetVariableDescriptorCountLayoutSupport *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
+            delete reinterpret_cast<const SubpassDescriptionDepthStencilResolve *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceDepthStencilResolveProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceScalarBlockLayoutFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
+            delete reinterpret_cast<const ImageStencilUsageCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
+            delete reinterpret_cast<const SamplerReductionModeCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceSamplerFilterMinmaxProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceVulkanMemoryModelFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceImagelessFramebufferFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+            delete reinterpret_cast<const FramebufferAttachmentsCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
+            delete reinterpret_cast<const RenderPassAttachmentBeginInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceUniformBufferStandardLayoutFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
+            delete reinterpret_cast<const AttachmentReferenceStencilLayout *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
+            delete reinterpret_cast<const AttachmentDescriptionStencilLayout *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceHostQueryResetFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceTimelineSemaphoreFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceTimelineSemaphoreProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+            delete reinterpret_cast<const SemaphoreTypeCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
+            delete reinterpret_cast<const TimelineSemaphoreSubmitInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceBufferDeviceAddressFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
+            delete reinterpret_cast<const BufferOpaqueCaptureAddressCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
+            delete reinterpret_cast<const MemoryOpaqueCaptureAddressAllocateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceVulkan13Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceVulkan13Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+            delete reinterpret_cast<const PipelineCreationFeedbackCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceShaderTerminateInvocationFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceShaderDemoteToHelperInvocationFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
+            delete reinterpret_cast<const PhysicalDevicePrivateDataFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
+            delete reinterpret_cast<const DevicePrivateDataCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
+            delete reinterpret_cast<const PhysicalDevicePipelineCreationCacheControlFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
+            delete reinterpret_cast<const MemoryBarrier2 *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceSynchronization2Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceImageRobustnessFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceSubgroupSizeControlFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceSubgroupSizeControlProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
+            delete reinterpret_cast<const PipelineShaderStageRequiredSubgroupSizeCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceInlineUniformBlockFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceInlineUniformBlockProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
+            delete reinterpret_cast<const WriteDescriptorSetInlineUniformBlock *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
+            delete reinterpret_cast<const DescriptorPoolInlineUniformBlockCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceTextureCompressionASTCHDRFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
+            delete reinterpret_cast<const PipelineRenderingCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceDynamicRenderingFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
+            delete reinterpret_cast<const CommandBufferInheritanceRenderingInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceShaderIntegerDotProductFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceShaderIntegerDotProductProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceTexelBufferAlignmentProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
+            delete reinterpret_cast<const FormatProperties3 *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
+            delete reinterpret_cast<const PhysicalDeviceMaintenance4Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
+            delete reinterpret_cast<const PhysicalDeviceMaintenance4Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+            delete reinterpret_cast<const ImageSwapchainCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+            delete reinterpret_cast<const BindImageMemorySwapchainInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+            delete reinterpret_cast<const DeviceGroupPresentInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+            delete reinterpret_cast<const DeviceGroupSwapchainCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+            delete reinterpret_cast<const DisplayPresentInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
+            delete reinterpret_cast<const QueueFamilyQueryResultStatusPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
+            delete reinterpret_cast<const QueueFamilyVideoPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const VideoProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
+            delete reinterpret_cast<const VideoProfileListInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
+            delete reinterpret_cast<const VideoDecodeCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeUsageInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR:
+            delete reinterpret_cast<const VideoEncodeH264CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
+            delete reinterpret_cast<const VideoEncodeH264QualityLevelPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH264SessionCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH264SessionParametersAddInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH264SessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH264SessionParametersGetInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH264SessionParametersFeedbackInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH264PictureInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH264DpbSlotInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH264ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH264RateControlInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH264RateControlLayerInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH264GopRemainingFrameInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR:
+            delete reinterpret_cast<const VideoEncodeH265CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH265SessionCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR:
+            delete reinterpret_cast<const VideoEncodeH265QualityLevelPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH265SessionParametersAddInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH265SessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH265SessionParametersGetInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH265SessionParametersFeedbackInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH265PictureInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH265DpbSlotInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH265ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH265RateControlInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH265RateControlLayerInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeH265GopRemainingFrameInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeH264ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR:
+            delete reinterpret_cast<const VideoDecodeH264CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeH264SessionParametersAddInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeH264SessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeH264PictureInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeH264DpbSlotInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+            delete reinterpret_cast<const RenderingFragmentShadingRateAttachmentInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
+            delete reinterpret_cast<const RenderingFragmentDensityMapAttachmentInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+            delete reinterpret_cast<const AttachmentSampleCountInfoAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
+            delete reinterpret_cast<const MultiviewPerViewAttributesInfoNVX *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const ImportMemoryWin32HandleInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const ExportMemoryWin32HandleInfoKHR *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+            delete reinterpret_cast<const ImportMemoryFdInfoKHR *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+            delete reinterpret_cast<const Win32KeyedMutexAcquireReleaseInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const ExportSemaphoreWin32HandleInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+            delete reinterpret_cast<const D3D12FenceSubmitInfoKHR *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDevicePushDescriptorPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+            delete reinterpret_cast<const PresentRegionsKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+            delete reinterpret_cast<const SharedPresentSurfaceCapabilitiesKHR *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const ExportFenceWin32HandleInfoKHR *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDevicePerformanceQueryFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDevicePerformanceQueryPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
+            delete reinterpret_cast<const QueryPoolPerformanceCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
+            delete reinterpret_cast<const PerformanceQuerySubmitInfoKHR *>(header);
+            break;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDevicePortabilitySubsetFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDevicePortabilitySubsetPropertiesKHR *>(header);
+            break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceShaderClockFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeH265ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR:
+            delete reinterpret_cast<const VideoDecodeH265CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeH265SessionParametersAddInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeH265SessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeH265PictureInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeH265DpbSlotInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
+            delete reinterpret_cast<const DeviceQueueGlobalPriorityCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceGlobalPriorityQueryFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
+            delete reinterpret_cast<const QueueFamilyGlobalPriorityPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+            delete reinterpret_cast<const FragmentShadingRateAttachmentInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
+            delete reinterpret_cast<const PipelineFragmentShadingRateStateCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceFragmentShadingRateFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceFragmentShadingRatePropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR:
+            delete reinterpret_cast<const RenderingAttachmentLocationInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR:
+            delete reinterpret_cast<const RenderingInputAttachmentIndexInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceShaderQuadControlFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
+            delete reinterpret_cast<const SurfaceProtectedCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDevicePresentWaitFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
+            delete reinterpret_cast<const PipelineLibraryCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
+            delete reinterpret_cast<const PresentIdKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDevicePresentIdFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
+            delete reinterpret_cast<const VideoEncodeCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
+            delete reinterpret_cast<const QueryPoolVideoEncodeFeedbackCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeUsageInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeRateControlInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
+            delete reinterpret_cast<const VideoEncodeQualityLevelInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
+            delete reinterpret_cast<const QueueFamilyCheckpointProperties2NV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceFragmentShaderBarycentricPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceShaderSubgroupRotateFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceMaintenance5FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceMaintenance5PropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
+            delete reinterpret_cast<const PipelineCreateFlags2CreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
+            delete reinterpret_cast<const BufferUsageFlags2CreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceCooperativeMatrixFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceCooperativeMatrixPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeAV1ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
+            delete reinterpret_cast<const VideoDecodeAV1CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeAV1SessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeAV1PictureInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
+            delete reinterpret_cast<const VideoDecodeAV1DpbSlotInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceVideoMaintenance1FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
+            delete reinterpret_cast<const VideoInlineQueryInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceVertexAttributeDivisorPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR:
+            delete reinterpret_cast<const PipelineVertexInputDivisorStateCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceVertexAttributeDivisorFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceShaderFloatControls2FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceIndexTypeUint8FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceLineRasterizationFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceLineRasterizationPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR:
+            delete reinterpret_cast<const PipelineRasterizationLineStateCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceShaderExpectAssumeFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceMaintenance6FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceMaintenance6PropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
+            delete reinterpret_cast<const BindMemoryStatusKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+            delete reinterpret_cast<const DebugReportCallbackCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+            delete reinterpret_cast<const PipelineRasterizationStateRasterizationOrderAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+            delete reinterpret_cast<const DedicatedAllocationImageCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+            delete reinterpret_cast<const DedicatedAllocationBufferCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+            delete reinterpret_cast<const DedicatedAllocationMemoryAllocateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceTransformFeedbackFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceTransformFeedbackPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
+            delete reinterpret_cast<const PipelineRasterizationStateStreamCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+            delete reinterpret_cast<const TextureLODGatherFormatPropertiesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceCornerSampledImageFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+            delete reinterpret_cast<const ExternalMemoryImageCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+            delete reinterpret_cast<const ExportMemoryAllocateInfoNV *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+            delete reinterpret_cast<const ImportMemoryWin32HandleInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+            delete reinterpret_cast<const ExportMemoryWin32HandleInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+            delete reinterpret_cast<const Win32KeyedMutexAcquireReleaseInfoNV *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+            delete reinterpret_cast<const ValidationFlagsEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
+            delete reinterpret_cast<const ImageViewASTCDecodeModeEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceASTCDecodeFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDevicePipelineRobustnessFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDevicePipelineRobustnessPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
+            delete reinterpret_cast<const PipelineRobustnessCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceConditionalRenderingFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+            delete reinterpret_cast<const CommandBufferInheritanceConditionalRenderingInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const PipelineViewportWScalingStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+            delete reinterpret_cast<const SwapchainCounterCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+            delete reinterpret_cast<const PresentTimesInfoGOOGLE *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+            delete reinterpret_cast<const PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const PipelineViewportSwizzleStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceDiscardRectanglePropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const PipelineDiscardRectangleStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceConservativeRasterizationPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const PipelineRasterizationConservativeStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceDepthClipEnableFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const PipelineRasterizationDepthClipStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
+            delete reinterpret_cast<const PhysicalDeviceRelaxedLineRasterizationFeaturesIMG *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
+            delete reinterpret_cast<const DebugUtilsObjectNameInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+            delete reinterpret_cast<const DebugUtilsMessengerCreateInfoEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+            delete reinterpret_cast<const AndroidHardwareBufferUsageANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+            delete reinterpret_cast<const AndroidHardwareBufferFormatPropertiesANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+            delete reinterpret_cast<const ImportAndroidHardwareBufferInfoANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+            delete reinterpret_cast<const ExternalFormatANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
+            delete reinterpret_cast<const AndroidHardwareBufferFormatProperties2ANDROID *>(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 PhysicalDeviceShaderEnqueueFeaturesAMDX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
+            delete reinterpret_cast<const PhysicalDeviceShaderEnqueuePropertiesAMDX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
+            delete reinterpret_cast<const PipelineShaderStageNodeCreateInfoAMDX *>(header);
+            break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+            delete reinterpret_cast<const SampleLocationsInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+            delete reinterpret_cast<const RenderPassSampleLocationsBeginInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const PipelineSampleLocationsStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceSampleLocationsPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const PipelineColorBlendAdvancedStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const PipelineCoverageToColorStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const PipelineCoverageModulationStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceShaderSMBuiltinsPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceShaderSMBuiltinsFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
+            delete reinterpret_cast<const DrmFormatModifierPropertiesListEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
+            delete reinterpret_cast<const PhysicalDeviceImageDrmFormatModifierInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
+            delete reinterpret_cast<const ImageDrmFormatModifierListCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
+            delete reinterpret_cast<const ImageDrmFormatModifierExplicitCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
+            delete reinterpret_cast<const DrmFormatModifierPropertiesList2EXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const ShaderModuleValidationCacheCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const PipelineViewportShadingRateImageStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceShadingRateImageFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceShadingRateImagePropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const PipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
+            delete reinterpret_cast<const WriteDescriptorSetAccelerationStructureNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceRayTracingPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const PipelineRepresentativeFragmentTestStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
+            delete reinterpret_cast<const PhysicalDeviceImageViewImageFormatInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
+            delete reinterpret_cast<const FilterCubicImageViewImageFormatPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+            delete reinterpret_cast<const ImportMemoryHostPointerInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceExternalMemoryHostPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+            delete reinterpret_cast<const PipelineCompilerControlCreateInfoAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+            delete reinterpret_cast<const PhysicalDeviceShaderCorePropertiesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
+            delete reinterpret_cast<const DeviceMemoryOverallocationCreateInfoAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_GGP
+        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
+            delete reinterpret_cast<const PresentFrameTokenGGP *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_GGP
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceComputeShaderDerivativesFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceMeshShaderFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceMeshShaderPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceShaderImageFootprintFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const PipelineViewportExclusiveScissorStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceExclusiveScissorFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+            delete reinterpret_cast<const QueueFamilyCheckpointPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+            delete reinterpret_cast<const PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
+            delete reinterpret_cast<const QueryPoolPerformanceQueryCreateInfoINTEL *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDevicePCIBusInfoPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
+            delete reinterpret_cast<const DisplayNativeHdrSurfaceCapabilitiesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
+            delete reinterpret_cast<const SwapchainDisplayNativeHdrCreateInfoAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceFragmentDensityMapFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceFragmentDensityMapPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
+            delete reinterpret_cast<const RenderPassFragmentDensityMapCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
+            delete reinterpret_cast<const PhysicalDeviceShaderCoreProperties2AMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+            delete reinterpret_cast<const PhysicalDeviceCoherentMemoryFeaturesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceMemoryBudgetPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceMemoryPriorityFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
+            delete reinterpret_cast<const MemoryPriorityAllocateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceBufferDeviceAddressFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
+            delete reinterpret_cast<const BufferDeviceAddressCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
+            delete reinterpret_cast<const ValidationFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceCooperativeMatrixFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceCooperativeMatrixPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceCoverageReductionModeFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const PipelineCoverageReductionStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceYcbcrImageArraysFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceProvokingVertexFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceProvokingVertexPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const PipelineRasterizationProvokingVertexStateCreateInfoEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
+            delete reinterpret_cast<const SurfaceFullScreenExclusiveInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
+            delete reinterpret_cast<const SurfaceCapabilitiesFullScreenExclusiveEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
+            delete reinterpret_cast<const SurfaceFullScreenExclusiveWin32InfoEXT *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceShaderAtomicFloatFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceExtendedDynamicStateFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceHostImageCopyFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceHostImageCopyPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
+            delete reinterpret_cast<const SubresourceHostMemcpySizeEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
+            delete reinterpret_cast<const HostImageCopyDevicePerformanceQueryEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceMapMemoryPlacedFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceMapMemoryPlacedPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
+            delete reinterpret_cast<const MemoryMapPlacedInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
+            delete reinterpret_cast<const SurfacePresentModeEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
+            delete reinterpret_cast<const SurfacePresentScalingCapabilitiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
+            delete reinterpret_cast<const SurfacePresentModeCompatibilityEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceSwapchainMaintenance1FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
+            delete reinterpret_cast<const SwapchainPresentFenceInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
+            delete reinterpret_cast<const SwapchainPresentModesCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
+            delete reinterpret_cast<const SwapchainPresentModeInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
+            delete reinterpret_cast<const SwapchainPresentScalingCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
+            delete reinterpret_cast<const GraphicsPipelineShaderGroupsCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceInheritedViewportScissorFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
+            delete reinterpret_cast<const CommandBufferInheritanceViewportScissorInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
+            delete reinterpret_cast<const RenderPassTransformBeginInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
+            delete reinterpret_cast<const CommandBufferInheritanceRenderPassTransformInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceDepthBiasControlFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
+            delete reinterpret_cast<const DepthBiasRepresentationInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceDeviceMemoryReportFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
+            delete reinterpret_cast<const DeviceDeviceMemoryReportCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceRobustness2FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceRobustness2PropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
+            delete reinterpret_cast<const SamplerCustomBorderColorCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceCustomBorderColorPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceCustomBorderColorFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDevicePresentBarrierFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
+            delete reinterpret_cast<const SurfaceCapabilitiesPresentBarrierNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
+            delete reinterpret_cast<const SwapchainPresentBarrierCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceDiagnosticsConfigFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
+            delete reinterpret_cast<const DeviceDiagnosticsConfigCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceCudaKernelLaunchFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceCudaKernelLaunchPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
+            delete reinterpret_cast<const QueryLowLatencySupportNV *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_METAL_EXT
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
+            delete reinterpret_cast<const ExportMetalObjectCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
+            delete reinterpret_cast<const ExportMetalDeviceInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
+            delete reinterpret_cast<const ExportMetalCommandQueueInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
+            delete reinterpret_cast<const ExportMetalBufferInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
+            delete reinterpret_cast<const ImportMetalBufferInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
+            delete reinterpret_cast<const ExportMetalTextureInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
+            delete reinterpret_cast<const ImportMetalTextureInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
+            delete reinterpret_cast<const ExportMetalIOSurfaceInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
+            delete reinterpret_cast<const ImportMetalIOSurfaceInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
+            delete reinterpret_cast<const ExportMetalSharedEventInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
+            delete reinterpret_cast<const ImportMetalSharedEventInfoEXT *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_METAL_EXT
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceDescriptorBufferPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceDescriptorBufferFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
+            delete reinterpret_cast<const DescriptorBufferBindingPushDescriptorBufferHandleEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
+            delete reinterpret_cast<const OpaqueCaptureDescriptorDataCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
+            delete reinterpret_cast<const GraphicsPipelineLibraryCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
+            delete reinterpret_cast<const PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const PipelineFragmentShadingRateEnumStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
+            delete reinterpret_cast<const AccelerationStructureGeometryMotionTrianglesDataNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
+            delete reinterpret_cast<const AccelerationStructureMotionInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceRayTracingMotionBlurFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceFragmentDensityMap2FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceFragmentDensityMap2PropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
+            delete reinterpret_cast<const CopyCommandTransformInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceImageCompressionControlFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
+            delete reinterpret_cast<const ImageCompressionControlEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
+            delete reinterpret_cast<const ImageCompressionPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDevice4444FormatsFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceFaultFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceRGBA10X6FormatsFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceMutableDescriptorTypeFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const MutableDescriptorTypeCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceDrmPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceAddressBindingReportFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
+            delete reinterpret_cast<const DeviceAddressBindingCallbackDataEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceDepthClipControlFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
+            delete reinterpret_cast<const PipelineViewportDepthClipControlCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_FUCHSIA
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
+            delete reinterpret_cast<const ImportMemoryZirconHandleInfoFUCHSIA *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
+            delete reinterpret_cast<const ImportMemoryBufferCollectionFUCHSIA *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
+            delete reinterpret_cast<const BufferCollectionImageCreateInfoFUCHSIA *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
+            delete reinterpret_cast<const BufferCollectionBufferCreateInfoFUCHSIA *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_FUCHSIA
+        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
+            delete reinterpret_cast<const SubpassShadingPipelineCreateInfoHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
+            delete reinterpret_cast<const PhysicalDeviceSubpassShadingFeaturesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
+            delete reinterpret_cast<const PhysicalDeviceSubpassShadingPropertiesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
+            delete reinterpret_cast<const PhysicalDeviceInvocationMaskFeaturesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceExternalMemoryRDMAFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDevicePipelinePropertiesFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceFrameBoundaryFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
+            delete reinterpret_cast<const FrameBoundaryEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
+            delete reinterpret_cast<const SubpassResolvePerformanceQueryEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
+            delete reinterpret_cast<const MultisampledRenderToSingleSampledInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceExtendedDynamicState2FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceColorWriteEnableFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const PipelineColorWriteCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceImageViewMinLodFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
+            delete reinterpret_cast<const ImageViewMinLodCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceMultiDrawFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceMultiDrawPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceImage2DViewOf3DFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceShaderTileImageFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceShaderTileImagePropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceOpacityMicromapFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceOpacityMicromapPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
+            delete reinterpret_cast<const AccelerationStructureTrianglesOpacityMicromapEXT *>(header);
+            break;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceDisplacementMicromapFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceDisplacementMicromapPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
+            delete reinterpret_cast<const AccelerationStructureTrianglesDisplacementMicromapNV *>(header);
+            break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
+            delete reinterpret_cast<const PhysicalDeviceClusterCullingShaderFeaturesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
+            delete reinterpret_cast<const PhysicalDeviceClusterCullingShaderPropertiesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI:
+            delete reinterpret_cast<const PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceBorderColorSwizzleFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
+            delete reinterpret_cast<const SamplerBorderColorComponentMappingCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
+            delete reinterpret_cast<const PhysicalDeviceShaderCorePropertiesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
+            delete reinterpret_cast<const DeviceQueueShaderCoreControlCreateInfoARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
+            delete reinterpret_cast<const PhysicalDeviceSchedulingControlsFeaturesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
+            delete reinterpret_cast<const PhysicalDeviceSchedulingControlsPropertiesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
+            delete reinterpret_cast<const ImageViewSlicedCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
+            delete reinterpret_cast<const PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceDepthClampZeroOneFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
+            delete reinterpret_cast<const PhysicalDeviceRenderPassStripedFeaturesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
+            delete reinterpret_cast<const PhysicalDeviceRenderPassStripedPropertiesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
+            delete reinterpret_cast<const RenderPassStripeBeginInfoARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
+            delete reinterpret_cast<const RenderPassStripeSubmitInfoARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
+            delete reinterpret_cast<const SubpassFragmentDensityMapOffsetEndInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceCopyMemoryIndirectFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceCopyMemoryIndirectPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceMemoryDecompressionFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceMemoryDecompressionPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
+            delete reinterpret_cast<const ComputePipelineIndirectBufferInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceLinearColorAttachmentFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
+            delete reinterpret_cast<const ImageViewSampleWeightCreateInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceImageProcessingFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceImageProcessingPropertiesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceNestedCommandBufferFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceNestedCommandBufferPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
+            delete reinterpret_cast<const ExternalMemoryAcquireUnmodifiedEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceExtendedDynamicState3FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceExtendedDynamicState3PropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceSubpassMergeFeedbackFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
+            delete reinterpret_cast<const RenderPassCreationControlEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
+            delete reinterpret_cast<const RenderPassCreationFeedbackCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
+            delete reinterpret_cast<const RenderPassSubpassFeedbackCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
+            delete reinterpret_cast<const DirectDriverLoadingListLUNARG *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceShaderModuleIdentifierPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
+            delete reinterpret_cast<const PipelineShaderStageModuleIdentifierCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceOpticalFlowFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceOpticalFlowPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
+            delete reinterpret_cast<const OpticalFlowImageFormatInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
+            delete reinterpret_cast<const OpticalFlowSessionCreatePrivateDataInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceLegacyDitheringFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDevicePipelineProtectedAccessFeaturesEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
+            delete reinterpret_cast<const PhysicalDeviceExternalFormatResolveFeaturesANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
+            delete reinterpret_cast<const PhysicalDeviceExternalFormatResolvePropertiesANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
+            delete reinterpret_cast<const AndroidHardwareBufferFormatResolvePropertiesANDROID *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceShaderObjectFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceShaderObjectPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceTilePropertiesFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC:
+            delete reinterpret_cast<const PhysicalDeviceAmigoProfilingFeaturesSEC *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
+            delete reinterpret_cast<const AmigoProfilingSubmitInfoSEC *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceRayTracingInvocationReorderPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
+            delete reinterpret_cast<const PhysicalDeviceExtendedSparseAddressSpacePropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
+            delete reinterpret_cast<const LayerSettingsCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
+            delete reinterpret_cast<const PhysicalDeviceShaderCoreBuiltinsFeaturesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
+            delete reinterpret_cast<const PhysicalDeviceShaderCoreBuiltinsPropertiesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
+            delete reinterpret_cast<const LatencySubmissionPresentIdNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
+            delete reinterpret_cast<const SwapchainLatencyCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
+            delete reinterpret_cast<const LatencySurfaceCapabilitiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
+            delete reinterpret_cast<const MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDevicePerStageDescriptorSetFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceImageProcessing2FeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceImageProcessing2PropertiesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
+            delete reinterpret_cast<const SamplerBlockMatchWindowCreateInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceCubicWeightsFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
+            delete reinterpret_cast<const SamplerCubicWeightsCreateInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM:
+            delete reinterpret_cast<const BlitImageCubicWeightsInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceYcbcrDegammaFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM:
+            delete reinterpret_cast<const SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
+            delete reinterpret_cast<const PhysicalDeviceCubicClampFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+        case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
+            delete reinterpret_cast<const ScreenBufferFormatPropertiesQNX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX:
+            delete reinterpret_cast<const ImportScreenBufferInfoQNX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX:
+            delete reinterpret_cast<const ExternalFormatQNX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX:
+            delete reinterpret_cast<const PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
+            delete reinterpret_cast<const PhysicalDeviceLayeredDriverPropertiesMSFT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceRawAccessChainsFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
+            delete reinterpret_cast<const PhysicalDeviceRayTracingValidationFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
+            delete reinterpret_cast<const WriteDescriptorSetAccelerationStructureKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceAccelerationStructureFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceAccelerationStructurePropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceRayTracingPipelineFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceRayTracingPipelinePropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
+            delete reinterpret_cast<const PhysicalDeviceRayQueryFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceMeshShaderFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
+            delete reinterpret_cast<const PhysicalDeviceMeshShaderPropertiesEXT *>(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 == 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 safe
+}  // 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..cd94fe4
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -0,0 +1,14966 @@
+// *** 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 {
+namespace safe {
+
+AttachmentSampleCountInfoAMD::AttachmentSampleCountInfoAMD(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);
+    }
+}
+
+AttachmentSampleCountInfoAMD::AttachmentSampleCountInfoAMD()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD),
+      pNext(nullptr),
+      colorAttachmentCount(),
+      pColorAttachmentSamples(nullptr),
+      depthStencilAttachmentSamples() {}
+
+AttachmentSampleCountInfoAMD::AttachmentSampleCountInfoAMD(const AttachmentSampleCountInfoAMD& 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);
+    }
+}
+
+AttachmentSampleCountInfoAMD& AttachmentSampleCountInfoAMD::operator=(const AttachmentSampleCountInfoAMD& 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;
+}
+
+AttachmentSampleCountInfoAMD::~AttachmentSampleCountInfoAMD() {
+    if (pColorAttachmentSamples) delete[] pColorAttachmentSamples;
+    FreePnextChain(pNext);
+}
+
+void AttachmentSampleCountInfoAMD::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 AttachmentSampleCountInfoAMD::initialize(const AttachmentSampleCountInfoAMD* 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);
+    }
+}
+
+MultiviewPerViewAttributesInfoNVX::MultiviewPerViewAttributesInfoNVX(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);
+    }
+}
+
+MultiviewPerViewAttributesInfoNVX::MultiviewPerViewAttributesInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX),
+      pNext(nullptr),
+      perViewAttributes(),
+      perViewAttributesPositionXOnly() {}
+
+MultiviewPerViewAttributesInfoNVX::MultiviewPerViewAttributesInfoNVX(const MultiviewPerViewAttributesInfoNVX& copy_src) {
+    sType = copy_src.sType;
+    perViewAttributes = copy_src.perViewAttributes;
+    perViewAttributesPositionXOnly = copy_src.perViewAttributesPositionXOnly;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MultiviewPerViewAttributesInfoNVX& MultiviewPerViewAttributesInfoNVX::operator=(const MultiviewPerViewAttributesInfoNVX& 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;
+}
+
+MultiviewPerViewAttributesInfoNVX::~MultiviewPerViewAttributesInfoNVX() { FreePnextChain(pNext); }
+
+void MultiviewPerViewAttributesInfoNVX::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 MultiviewPerViewAttributesInfoNVX::initialize(const MultiviewPerViewAttributesInfoNVX* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    perViewAttributes = copy_src->perViewAttributes;
+    perViewAttributesPositionXOnly = copy_src->perViewAttributesPositionXOnly;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+QueueFamilyCheckpointProperties2NV::QueueFamilyCheckpointProperties2NV(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);
+    }
+}
+
+QueueFamilyCheckpointProperties2NV::QueueFamilyCheckpointProperties2NV()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV), pNext(nullptr), checkpointExecutionStageMask() {}
+
+QueueFamilyCheckpointProperties2NV::QueueFamilyCheckpointProperties2NV(const QueueFamilyCheckpointProperties2NV& copy_src) {
+    sType = copy_src.sType;
+    checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+QueueFamilyCheckpointProperties2NV& QueueFamilyCheckpointProperties2NV::operator=(
+    const QueueFamilyCheckpointProperties2NV& 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;
+}
+
+QueueFamilyCheckpointProperties2NV::~QueueFamilyCheckpointProperties2NV() { FreePnextChain(pNext); }
+
+void QueueFamilyCheckpointProperties2NV::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 QueueFamilyCheckpointProperties2NV::initialize(const QueueFamilyCheckpointProperties2NV* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    checkpointExecutionStageMask = copy_src->checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CheckpointData2NV::CheckpointData2NV(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);
+    }
+}
+
+CheckpointData2NV::CheckpointData2NV()
+    : sType(VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV), pNext(nullptr), stage(), pCheckpointMarker(nullptr) {}
+
+CheckpointData2NV::CheckpointData2NV(const CheckpointData2NV& copy_src) {
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    pCheckpointMarker = copy_src.pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CheckpointData2NV& CheckpointData2NV::operator=(const CheckpointData2NV& 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;
+}
+
+CheckpointData2NV::~CheckpointData2NV() { FreePnextChain(pNext); }
+
+void CheckpointData2NV::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 CheckpointData2NV::initialize(const CheckpointData2NV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stage = copy_src->stage;
+    pCheckpointMarker = copy_src->pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineRasterizationStateRasterizationOrderAMD::PipelineRasterizationStateRasterizationOrderAMD(
+    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);
+    }
+}
+
+PipelineRasterizationStateRasterizationOrderAMD::PipelineRasterizationStateRasterizationOrderAMD()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD), pNext(nullptr), rasterizationOrder() {}
+
+PipelineRasterizationStateRasterizationOrderAMD::PipelineRasterizationStateRasterizationOrderAMD(
+    const PipelineRasterizationStateRasterizationOrderAMD& copy_src) {
+    sType = copy_src.sType;
+    rasterizationOrder = copy_src.rasterizationOrder;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineRasterizationStateRasterizationOrderAMD& PipelineRasterizationStateRasterizationOrderAMD::operator=(
+    const PipelineRasterizationStateRasterizationOrderAMD& 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;
+}
+
+PipelineRasterizationStateRasterizationOrderAMD::~PipelineRasterizationStateRasterizationOrderAMD() { FreePnextChain(pNext); }
+
+void PipelineRasterizationStateRasterizationOrderAMD::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 PipelineRasterizationStateRasterizationOrderAMD::initialize(const PipelineRasterizationStateRasterizationOrderAMD* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rasterizationOrder = copy_src->rasterizationOrder;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DedicatedAllocationImageCreateInfoNV::DedicatedAllocationImageCreateInfoNV(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);
+    }
+}
+
+DedicatedAllocationImageCreateInfoNV::DedicatedAllocationImageCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV), pNext(nullptr), dedicatedAllocation() {}
+
+DedicatedAllocationImageCreateInfoNV::DedicatedAllocationImageCreateInfoNV(const DedicatedAllocationImageCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    dedicatedAllocation = copy_src.dedicatedAllocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DedicatedAllocationImageCreateInfoNV& DedicatedAllocationImageCreateInfoNV::operator=(
+    const DedicatedAllocationImageCreateInfoNV& 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;
+}
+
+DedicatedAllocationImageCreateInfoNV::~DedicatedAllocationImageCreateInfoNV() { FreePnextChain(pNext); }
+
+void DedicatedAllocationImageCreateInfoNV::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 DedicatedAllocationImageCreateInfoNV::initialize(const DedicatedAllocationImageCreateInfoNV* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dedicatedAllocation = copy_src->dedicatedAllocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DedicatedAllocationBufferCreateInfoNV::DedicatedAllocationBufferCreateInfoNV(
+    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);
+    }
+}
+
+DedicatedAllocationBufferCreateInfoNV::DedicatedAllocationBufferCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV), pNext(nullptr), dedicatedAllocation() {}
+
+DedicatedAllocationBufferCreateInfoNV::DedicatedAllocationBufferCreateInfoNV(
+    const DedicatedAllocationBufferCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    dedicatedAllocation = copy_src.dedicatedAllocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DedicatedAllocationBufferCreateInfoNV& DedicatedAllocationBufferCreateInfoNV::operator=(
+    const DedicatedAllocationBufferCreateInfoNV& 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;
+}
+
+DedicatedAllocationBufferCreateInfoNV::~DedicatedAllocationBufferCreateInfoNV() { FreePnextChain(pNext); }
+
+void DedicatedAllocationBufferCreateInfoNV::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 DedicatedAllocationBufferCreateInfoNV::initialize(const DedicatedAllocationBufferCreateInfoNV* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dedicatedAllocation = copy_src->dedicatedAllocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DedicatedAllocationMemoryAllocateInfoNV::DedicatedAllocationMemoryAllocateInfoNV(
+    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);
+    }
+}
+
+DedicatedAllocationMemoryAllocateInfoNV::DedicatedAllocationMemoryAllocateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV), pNext(nullptr), image(), buffer() {}
+
+DedicatedAllocationMemoryAllocateInfoNV::DedicatedAllocationMemoryAllocateInfoNV(
+    const DedicatedAllocationMemoryAllocateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DedicatedAllocationMemoryAllocateInfoNV& DedicatedAllocationMemoryAllocateInfoNV::operator=(
+    const DedicatedAllocationMemoryAllocateInfoNV& 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;
+}
+
+DedicatedAllocationMemoryAllocateInfoNV::~DedicatedAllocationMemoryAllocateInfoNV() { FreePnextChain(pNext); }
+
+void DedicatedAllocationMemoryAllocateInfoNV::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 DedicatedAllocationMemoryAllocateInfoNV::initialize(const DedicatedAllocationMemoryAllocateInfoNV* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CuModuleCreateInfoNVX::CuModuleCreateInfoNVX(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;
+    }
+}
+
+CuModuleCreateInfoNVX::CuModuleCreateInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX), pNext(nullptr), dataSize(), pData(nullptr) {}
+
+CuModuleCreateInfoNVX::CuModuleCreateInfoNVX(const CuModuleCreateInfoNVX& 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;
+    }
+}
+
+CuModuleCreateInfoNVX& CuModuleCreateInfoNVX::operator=(const CuModuleCreateInfoNVX& 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;
+}
+
+CuModuleCreateInfoNVX::~CuModuleCreateInfoNVX() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+}
+
+void CuModuleCreateInfoNVX::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 CuModuleCreateInfoNVX::initialize(const CuModuleCreateInfoNVX* 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;
+    }
+}
+
+CuFunctionCreateInfoNVX::CuFunctionCreateInfoNVX(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);
+}
+
+CuFunctionCreateInfoNVX::CuFunctionCreateInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX), pNext(nullptr), module(), pName(nullptr) {}
+
+CuFunctionCreateInfoNVX::CuFunctionCreateInfoNVX(const CuFunctionCreateInfoNVX& copy_src) {
+    sType = copy_src.sType;
+    module = copy_src.module;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+}
+
+CuFunctionCreateInfoNVX& CuFunctionCreateInfoNVX::operator=(const CuFunctionCreateInfoNVX& 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;
+}
+
+CuFunctionCreateInfoNVX::~CuFunctionCreateInfoNVX() {
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+}
+
+void CuFunctionCreateInfoNVX::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 CuFunctionCreateInfoNVX::initialize(const CuFunctionCreateInfoNVX* 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);
+}
+
+CuLaunchInfoNVX::CuLaunchInfoNVX(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);
+    }
+}
+
+CuLaunchInfoNVX::CuLaunchInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX),
+      pNext(nullptr),
+      function(),
+      gridDimX(),
+      gridDimY(),
+      gridDimZ(),
+      blockDimX(),
+      blockDimY(),
+      blockDimZ(),
+      sharedMemBytes(),
+      paramCount(),
+      pParams(nullptr),
+      extraCount(),
+      pExtras(nullptr) {}
+
+CuLaunchInfoNVX::CuLaunchInfoNVX(const CuLaunchInfoNVX& 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);
+}
+
+CuLaunchInfoNVX& CuLaunchInfoNVX::operator=(const CuLaunchInfoNVX& 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;
+}
+
+CuLaunchInfoNVX::~CuLaunchInfoNVX() { FreePnextChain(pNext); }
+
+void CuLaunchInfoNVX::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 CuLaunchInfoNVX::initialize(const CuLaunchInfoNVX* 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);
+}
+
+ImageViewHandleInfoNVX::ImageViewHandleInfoNVX(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);
+    }
+}
+
+ImageViewHandleInfoNVX::ImageViewHandleInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX), pNext(nullptr), imageView(), descriptorType(), sampler() {}
+
+ImageViewHandleInfoNVX::ImageViewHandleInfoNVX(const ImageViewHandleInfoNVX& copy_src) {
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    descriptorType = copy_src.descriptorType;
+    sampler = copy_src.sampler;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageViewHandleInfoNVX& ImageViewHandleInfoNVX::operator=(const ImageViewHandleInfoNVX& 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;
+}
+
+ImageViewHandleInfoNVX::~ImageViewHandleInfoNVX() { FreePnextChain(pNext); }
+
+void ImageViewHandleInfoNVX::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 ImageViewHandleInfoNVX::initialize(const ImageViewHandleInfoNVX* 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);
+}
+
+ImageViewAddressPropertiesNVX::ImageViewAddressPropertiesNVX(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);
+    }
+}
+
+ImageViewAddressPropertiesNVX::ImageViewAddressPropertiesNVX()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX), pNext(nullptr), deviceAddress(), size() {}
+
+ImageViewAddressPropertiesNVX::ImageViewAddressPropertiesNVX(const ImageViewAddressPropertiesNVX& copy_src) {
+    sType = copy_src.sType;
+    deviceAddress = copy_src.deviceAddress;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageViewAddressPropertiesNVX& ImageViewAddressPropertiesNVX::operator=(const ImageViewAddressPropertiesNVX& 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;
+}
+
+ImageViewAddressPropertiesNVX::~ImageViewAddressPropertiesNVX() { FreePnextChain(pNext); }
+
+void ImageViewAddressPropertiesNVX::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 ImageViewAddressPropertiesNVX::initialize(const ImageViewAddressPropertiesNVX* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceAddress = copy_src->deviceAddress;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+TextureLODGatherFormatPropertiesAMD::TextureLODGatherFormatPropertiesAMD(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);
+    }
+}
+
+TextureLODGatherFormatPropertiesAMD::TextureLODGatherFormatPropertiesAMD()
+    : sType(VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD), pNext(nullptr), supportsTextureGatherLODBiasAMD() {}
+
+TextureLODGatherFormatPropertiesAMD::TextureLODGatherFormatPropertiesAMD(const TextureLODGatherFormatPropertiesAMD& copy_src) {
+    sType = copy_src.sType;
+    supportsTextureGatherLODBiasAMD = copy_src.supportsTextureGatherLODBiasAMD;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+TextureLODGatherFormatPropertiesAMD& TextureLODGatherFormatPropertiesAMD::operator=(
+    const TextureLODGatherFormatPropertiesAMD& 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;
+}
+
+TextureLODGatherFormatPropertiesAMD::~TextureLODGatherFormatPropertiesAMD() { FreePnextChain(pNext); }
+
+void TextureLODGatherFormatPropertiesAMD::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 TextureLODGatherFormatPropertiesAMD::initialize(const TextureLODGatherFormatPropertiesAMD* 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
+
+StreamDescriptorSurfaceCreateInfoGGP::StreamDescriptorSurfaceCreateInfoGGP(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);
+    }
+}
+
+StreamDescriptorSurfaceCreateInfoGGP::StreamDescriptorSurfaceCreateInfoGGP()
+    : sType(VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP), pNext(nullptr), flags(), streamDescriptor() {}
+
+StreamDescriptorSurfaceCreateInfoGGP::StreamDescriptorSurfaceCreateInfoGGP(const StreamDescriptorSurfaceCreateInfoGGP& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    streamDescriptor = copy_src.streamDescriptor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+StreamDescriptorSurfaceCreateInfoGGP& StreamDescriptorSurfaceCreateInfoGGP::operator=(
+    const StreamDescriptorSurfaceCreateInfoGGP& 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;
+}
+
+StreamDescriptorSurfaceCreateInfoGGP::~StreamDescriptorSurfaceCreateInfoGGP() { FreePnextChain(pNext); }
+
+void StreamDescriptorSurfaceCreateInfoGGP::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 StreamDescriptorSurfaceCreateInfoGGP::initialize(const StreamDescriptorSurfaceCreateInfoGGP* 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
+
+PhysicalDeviceCornerSampledImageFeaturesNV::PhysicalDeviceCornerSampledImageFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceCornerSampledImageFeaturesNV::PhysicalDeviceCornerSampledImageFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV), pNext(nullptr), cornerSampledImage() {}
+
+PhysicalDeviceCornerSampledImageFeaturesNV::PhysicalDeviceCornerSampledImageFeaturesNV(
+    const PhysicalDeviceCornerSampledImageFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    cornerSampledImage = copy_src.cornerSampledImage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCornerSampledImageFeaturesNV& PhysicalDeviceCornerSampledImageFeaturesNV::operator=(
+    const PhysicalDeviceCornerSampledImageFeaturesNV& 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;
+}
+
+PhysicalDeviceCornerSampledImageFeaturesNV::~PhysicalDeviceCornerSampledImageFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCornerSampledImageFeaturesNV::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 PhysicalDeviceCornerSampledImageFeaturesNV::initialize(const PhysicalDeviceCornerSampledImageFeaturesNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cornerSampledImage = copy_src->cornerSampledImage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExternalMemoryImageCreateInfoNV::ExternalMemoryImageCreateInfoNV(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);
+    }
+}
+
+ExternalMemoryImageCreateInfoNV::ExternalMemoryImageCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV), pNext(nullptr), handleTypes() {}
+
+ExternalMemoryImageCreateInfoNV::ExternalMemoryImageCreateInfoNV(const ExternalMemoryImageCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExternalMemoryImageCreateInfoNV& ExternalMemoryImageCreateInfoNV::operator=(const ExternalMemoryImageCreateInfoNV& 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;
+}
+
+ExternalMemoryImageCreateInfoNV::~ExternalMemoryImageCreateInfoNV() { FreePnextChain(pNext); }
+
+void ExternalMemoryImageCreateInfoNV::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 ExternalMemoryImageCreateInfoNV::initialize(const ExternalMemoryImageCreateInfoNV* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExportMemoryAllocateInfoNV::ExportMemoryAllocateInfoNV(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);
+    }
+}
+
+ExportMemoryAllocateInfoNV::ExportMemoryAllocateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV), pNext(nullptr), handleTypes() {}
+
+ExportMemoryAllocateInfoNV::ExportMemoryAllocateInfoNV(const ExportMemoryAllocateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExportMemoryAllocateInfoNV& ExportMemoryAllocateInfoNV::operator=(const ExportMemoryAllocateInfoNV& 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;
+}
+
+ExportMemoryAllocateInfoNV::~ExportMemoryAllocateInfoNV() { FreePnextChain(pNext); }
+
+void ExportMemoryAllocateInfoNV::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 ExportMemoryAllocateInfoNV::initialize(const ExportMemoryAllocateInfoNV* 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
+
+ImportMemoryWin32HandleInfoNV::ImportMemoryWin32HandleInfoNV(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);
+    }
+}
+
+ImportMemoryWin32HandleInfoNV::ImportMemoryWin32HandleInfoNV()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV), pNext(nullptr), handleType(), handle() {}
+
+ImportMemoryWin32HandleInfoNV::ImportMemoryWin32HandleInfoNV(const ImportMemoryWin32HandleInfoNV& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImportMemoryWin32HandleInfoNV& ImportMemoryWin32HandleInfoNV::operator=(const ImportMemoryWin32HandleInfoNV& 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;
+}
+
+ImportMemoryWin32HandleInfoNV::~ImportMemoryWin32HandleInfoNV() { FreePnextChain(pNext); }
+
+void ImportMemoryWin32HandleInfoNV::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 ImportMemoryWin32HandleInfoNV::initialize(const ImportMemoryWin32HandleInfoNV* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    handle = copy_src->handle;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExportMemoryWin32HandleInfoNV::ExportMemoryWin32HandleInfoNV(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);
+    }
+}
+
+ExportMemoryWin32HandleInfoNV::ExportMemoryWin32HandleInfoNV()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV), pNext(nullptr), pAttributes(nullptr), dwAccess() {}
+
+ExportMemoryWin32HandleInfoNV::ExportMemoryWin32HandleInfoNV(const ExportMemoryWin32HandleInfoNV& 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);
+    }
+}
+
+ExportMemoryWin32HandleInfoNV& ExportMemoryWin32HandleInfoNV::operator=(const ExportMemoryWin32HandleInfoNV& 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;
+}
+
+ExportMemoryWin32HandleInfoNV::~ExportMemoryWin32HandleInfoNV() {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+}
+
+void ExportMemoryWin32HandleInfoNV::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 ExportMemoryWin32HandleInfoNV::initialize(const ExportMemoryWin32HandleInfoNV* 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);
+    }
+}
+
+Win32KeyedMutexAcquireReleaseInfoNV::Win32KeyedMutexAcquireReleaseInfoNV(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);
+    }
+}
+
+Win32KeyedMutexAcquireReleaseInfoNV::Win32KeyedMutexAcquireReleaseInfoNV()
+    : 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) {}
+
+Win32KeyedMutexAcquireReleaseInfoNV::Win32KeyedMutexAcquireReleaseInfoNV(const Win32KeyedMutexAcquireReleaseInfoNV& 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);
+    }
+}
+
+Win32KeyedMutexAcquireReleaseInfoNV& Win32KeyedMutexAcquireReleaseInfoNV::operator=(
+    const Win32KeyedMutexAcquireReleaseInfoNV& 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;
+}
+
+Win32KeyedMutexAcquireReleaseInfoNV::~Win32KeyedMutexAcquireReleaseInfoNV() {
+    if (pAcquireSyncs) delete[] pAcquireSyncs;
+    if (pAcquireKeys) delete[] pAcquireKeys;
+    if (pAcquireTimeoutMilliseconds) delete[] pAcquireTimeoutMilliseconds;
+    if (pReleaseSyncs) delete[] pReleaseSyncs;
+    if (pReleaseKeys) delete[] pReleaseKeys;
+    FreePnextChain(pNext);
+}
+
+void Win32KeyedMutexAcquireReleaseInfoNV::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 Win32KeyedMutexAcquireReleaseInfoNV::initialize(const Win32KeyedMutexAcquireReleaseInfoNV* 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
+
+ViSurfaceCreateInfoNN::ViSurfaceCreateInfoNN(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);
+    }
+}
+
+ViSurfaceCreateInfoNN::ViSurfaceCreateInfoNN()
+    : sType(VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN), pNext(nullptr), flags(), window(nullptr) {}
+
+ViSurfaceCreateInfoNN::ViSurfaceCreateInfoNN(const ViSurfaceCreateInfoNN& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    window = copy_src.window;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ViSurfaceCreateInfoNN& ViSurfaceCreateInfoNN::operator=(const ViSurfaceCreateInfoNN& 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;
+}
+
+ViSurfaceCreateInfoNN::~ViSurfaceCreateInfoNN() { FreePnextChain(pNext); }
+
+void ViSurfaceCreateInfoNN::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 ViSurfaceCreateInfoNN::initialize(const ViSurfaceCreateInfoNN* 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
+
+PipelineViewportWScalingStateCreateInfoNV::PipelineViewportWScalingStateCreateInfoNV(
+    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);
+    }
+}
+
+PipelineViewportWScalingStateCreateInfoNV::PipelineViewportWScalingStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      viewportWScalingEnable(),
+      viewportCount(),
+      pViewportWScalings(nullptr) {}
+
+PipelineViewportWScalingStateCreateInfoNV::PipelineViewportWScalingStateCreateInfoNV(
+    const PipelineViewportWScalingStateCreateInfoNV& 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);
+    }
+}
+
+PipelineViewportWScalingStateCreateInfoNV& PipelineViewportWScalingStateCreateInfoNV::operator=(
+    const PipelineViewportWScalingStateCreateInfoNV& 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;
+}
+
+PipelineViewportWScalingStateCreateInfoNV::~PipelineViewportWScalingStateCreateInfoNV() {
+    if (pViewportWScalings) delete[] pViewportWScalings;
+    FreePnextChain(pNext);
+}
+
+void PipelineViewportWScalingStateCreateInfoNV::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 PipelineViewportWScalingStateCreateInfoNV::initialize(const PipelineViewportWScalingStateCreateInfoNV* 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);
+    }
+}
+
+PresentTimesInfoGOOGLE::PresentTimesInfoGOOGLE(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);
+    }
+}
+
+PresentTimesInfoGOOGLE::PresentTimesInfoGOOGLE()
+    : sType(VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE), pNext(nullptr), swapchainCount(), pTimes(nullptr) {}
+
+PresentTimesInfoGOOGLE::PresentTimesInfoGOOGLE(const PresentTimesInfoGOOGLE& 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);
+    }
+}
+
+PresentTimesInfoGOOGLE& PresentTimesInfoGOOGLE::operator=(const PresentTimesInfoGOOGLE& 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;
+}
+
+PresentTimesInfoGOOGLE::~PresentTimesInfoGOOGLE() {
+    if (pTimes) delete[] pTimes;
+    FreePnextChain(pNext);
+}
+
+void PresentTimesInfoGOOGLE::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 PresentTimesInfoGOOGLE::initialize(const PresentTimesInfoGOOGLE* 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);
+    }
+}
+
+PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    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);
+    }
+}
+
+PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX),
+      pNext(nullptr),
+      perViewPositionAllComponents() {}
+
+PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    const PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src) {
+    sType = copy_src.sType;
+    perViewPositionAllComponents = copy_src.perViewPositionAllComponents;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::operator=(
+    const PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& 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;
+}
+
+PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::~PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::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 PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize(
+    const PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    perViewPositionAllComponents = copy_src->perViewPositionAllComponents;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineViewportSwizzleStateCreateInfoNV::PipelineViewportSwizzleStateCreateInfoNV(
+    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);
+    }
+}
+
+PipelineViewportSwizzleStateCreateInfoNV::PipelineViewportSwizzleStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      flags(),
+      viewportCount(),
+      pViewportSwizzles(nullptr) {}
+
+PipelineViewportSwizzleStateCreateInfoNV::PipelineViewportSwizzleStateCreateInfoNV(
+    const PipelineViewportSwizzleStateCreateInfoNV& 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);
+    }
+}
+
+PipelineViewportSwizzleStateCreateInfoNV& PipelineViewportSwizzleStateCreateInfoNV::operator=(
+    const PipelineViewportSwizzleStateCreateInfoNV& 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;
+}
+
+PipelineViewportSwizzleStateCreateInfoNV::~PipelineViewportSwizzleStateCreateInfoNV() {
+    if (pViewportSwizzles) delete[] pViewportSwizzles;
+    FreePnextChain(pNext);
+}
+
+void PipelineViewportSwizzleStateCreateInfoNV::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 PipelineViewportSwizzleStateCreateInfoNV::initialize(const PipelineViewportSwizzleStateCreateInfoNV* 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);
+    }
+}
+
+PhysicalDeviceRelaxedLineRasterizationFeaturesIMG::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG(
+    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);
+    }
+}
+
+PhysicalDeviceRelaxedLineRasterizationFeaturesIMG::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG),
+      pNext(nullptr),
+      relaxedLineRasterization() {}
+
+PhysicalDeviceRelaxedLineRasterizationFeaturesIMG::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG(
+    const PhysicalDeviceRelaxedLineRasterizationFeaturesIMG& copy_src) {
+    sType = copy_src.sType;
+    relaxedLineRasterization = copy_src.relaxedLineRasterization;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRelaxedLineRasterizationFeaturesIMG& PhysicalDeviceRelaxedLineRasterizationFeaturesIMG::operator=(
+    const PhysicalDeviceRelaxedLineRasterizationFeaturesIMG& 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;
+}
+
+PhysicalDeviceRelaxedLineRasterizationFeaturesIMG::~PhysicalDeviceRelaxedLineRasterizationFeaturesIMG() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRelaxedLineRasterizationFeaturesIMG::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 PhysicalDeviceRelaxedLineRasterizationFeaturesIMG::initialize(
+    const PhysicalDeviceRelaxedLineRasterizationFeaturesIMG* 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
+
+AndroidHardwareBufferUsageANDROID::AndroidHardwareBufferUsageANDROID(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);
+    }
+}
+
+AndroidHardwareBufferUsageANDROID::AndroidHardwareBufferUsageANDROID()
+    : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID), pNext(nullptr), androidHardwareBufferUsage() {}
+
+AndroidHardwareBufferUsageANDROID::AndroidHardwareBufferUsageANDROID(const AndroidHardwareBufferUsageANDROID& copy_src) {
+    sType = copy_src.sType;
+    androidHardwareBufferUsage = copy_src.androidHardwareBufferUsage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AndroidHardwareBufferUsageANDROID& AndroidHardwareBufferUsageANDROID::operator=(const AndroidHardwareBufferUsageANDROID& 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;
+}
+
+AndroidHardwareBufferUsageANDROID::~AndroidHardwareBufferUsageANDROID() { FreePnextChain(pNext); }
+
+void AndroidHardwareBufferUsageANDROID::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 AndroidHardwareBufferUsageANDROID::initialize(const AndroidHardwareBufferUsageANDROID* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    androidHardwareBufferUsage = copy_src->androidHardwareBufferUsage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+AndroidHardwareBufferPropertiesANDROID::AndroidHardwareBufferPropertiesANDROID(
+    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);
+    }
+}
+
+AndroidHardwareBufferPropertiesANDROID::AndroidHardwareBufferPropertiesANDROID()
+    : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID), pNext(nullptr), allocationSize(), memoryTypeBits() {}
+
+AndroidHardwareBufferPropertiesANDROID::AndroidHardwareBufferPropertiesANDROID(
+    const AndroidHardwareBufferPropertiesANDROID& copy_src) {
+    sType = copy_src.sType;
+    allocationSize = copy_src.allocationSize;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AndroidHardwareBufferPropertiesANDROID& AndroidHardwareBufferPropertiesANDROID::operator=(
+    const AndroidHardwareBufferPropertiesANDROID& 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;
+}
+
+AndroidHardwareBufferPropertiesANDROID::~AndroidHardwareBufferPropertiesANDROID() { FreePnextChain(pNext); }
+
+void AndroidHardwareBufferPropertiesANDROID::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 AndroidHardwareBufferPropertiesANDROID::initialize(const AndroidHardwareBufferPropertiesANDROID* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    allocationSize = copy_src->allocationSize;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+AndroidHardwareBufferFormatPropertiesANDROID::AndroidHardwareBufferFormatPropertiesANDROID(
+    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);
+    }
+}
+
+AndroidHardwareBufferFormatPropertiesANDROID::AndroidHardwareBufferFormatPropertiesANDROID()
+    : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID),
+      pNext(nullptr),
+      format(),
+      externalFormat(),
+      formatFeatures(),
+      samplerYcbcrConversionComponents(),
+      suggestedYcbcrModel(),
+      suggestedYcbcrRange(),
+      suggestedXChromaOffset(),
+      suggestedYChromaOffset() {}
+
+AndroidHardwareBufferFormatPropertiesANDROID::AndroidHardwareBufferFormatPropertiesANDROID(
+    const AndroidHardwareBufferFormatPropertiesANDROID& 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);
+}
+
+AndroidHardwareBufferFormatPropertiesANDROID& AndroidHardwareBufferFormatPropertiesANDROID::operator=(
+    const AndroidHardwareBufferFormatPropertiesANDROID& 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;
+}
+
+AndroidHardwareBufferFormatPropertiesANDROID::~AndroidHardwareBufferFormatPropertiesANDROID() { FreePnextChain(pNext); }
+
+void AndroidHardwareBufferFormatPropertiesANDROID::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 AndroidHardwareBufferFormatPropertiesANDROID::initialize(const AndroidHardwareBufferFormatPropertiesANDROID* 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);
+}
+
+ImportAndroidHardwareBufferInfoANDROID::ImportAndroidHardwareBufferInfoANDROID(
+    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;
+}
+
+ImportAndroidHardwareBufferInfoANDROID::ImportAndroidHardwareBufferInfoANDROID()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID), pNext(nullptr), buffer(nullptr) {}
+
+ImportAndroidHardwareBufferInfoANDROID::ImportAndroidHardwareBufferInfoANDROID(
+    const ImportAndroidHardwareBufferInfoANDROID& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+    buffer = copy_src.buffer;
+}
+
+ImportAndroidHardwareBufferInfoANDROID& ImportAndroidHardwareBufferInfoANDROID::operator=(
+    const ImportAndroidHardwareBufferInfoANDROID& 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;
+}
+
+ImportAndroidHardwareBufferInfoANDROID::~ImportAndroidHardwareBufferInfoANDROID() { FreePnextChain(pNext); }
+
+void ImportAndroidHardwareBufferInfoANDROID::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 ImportAndroidHardwareBufferInfoANDROID::initialize(const ImportAndroidHardwareBufferInfoANDROID* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+    buffer = copy_src->buffer;
+}
+
+MemoryGetAndroidHardwareBufferInfoANDROID::MemoryGetAndroidHardwareBufferInfoANDROID(
+    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);
+    }
+}
+
+MemoryGetAndroidHardwareBufferInfoANDROID::MemoryGetAndroidHardwareBufferInfoANDROID()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID), pNext(nullptr), memory() {}
+
+MemoryGetAndroidHardwareBufferInfoANDROID::MemoryGetAndroidHardwareBufferInfoANDROID(
+    const MemoryGetAndroidHardwareBufferInfoANDROID& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryGetAndroidHardwareBufferInfoANDROID& MemoryGetAndroidHardwareBufferInfoANDROID::operator=(
+    const MemoryGetAndroidHardwareBufferInfoANDROID& 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;
+}
+
+MemoryGetAndroidHardwareBufferInfoANDROID::~MemoryGetAndroidHardwareBufferInfoANDROID() { FreePnextChain(pNext); }
+
+void MemoryGetAndroidHardwareBufferInfoANDROID::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 MemoryGetAndroidHardwareBufferInfoANDROID::initialize(const MemoryGetAndroidHardwareBufferInfoANDROID* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExternalFormatANDROID::ExternalFormatANDROID(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);
+    }
+}
+
+ExternalFormatANDROID::ExternalFormatANDROID()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID), pNext(nullptr), externalFormat() {}
+
+ExternalFormatANDROID::ExternalFormatANDROID(const ExternalFormatANDROID& copy_src) {
+    sType = copy_src.sType;
+    externalFormat = copy_src.externalFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExternalFormatANDROID& ExternalFormatANDROID::operator=(const ExternalFormatANDROID& 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;
+}
+
+ExternalFormatANDROID::~ExternalFormatANDROID() { FreePnextChain(pNext); }
+
+void ExternalFormatANDROID::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 ExternalFormatANDROID::initialize(const ExternalFormatANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalFormat = copy_src->externalFormat;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+AndroidHardwareBufferFormatProperties2ANDROID::AndroidHardwareBufferFormatProperties2ANDROID(
+    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);
+    }
+}
+
+AndroidHardwareBufferFormatProperties2ANDROID::AndroidHardwareBufferFormatProperties2ANDROID()
+    : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID),
+      pNext(nullptr),
+      format(),
+      externalFormat(),
+      formatFeatures(),
+      samplerYcbcrConversionComponents(),
+      suggestedYcbcrModel(),
+      suggestedYcbcrRange(),
+      suggestedXChromaOffset(),
+      suggestedYChromaOffset() {}
+
+AndroidHardwareBufferFormatProperties2ANDROID::AndroidHardwareBufferFormatProperties2ANDROID(
+    const AndroidHardwareBufferFormatProperties2ANDROID& 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);
+}
+
+AndroidHardwareBufferFormatProperties2ANDROID& AndroidHardwareBufferFormatProperties2ANDROID::operator=(
+    const AndroidHardwareBufferFormatProperties2ANDROID& 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;
+}
+
+AndroidHardwareBufferFormatProperties2ANDROID::~AndroidHardwareBufferFormatProperties2ANDROID() { FreePnextChain(pNext); }
+
+void AndroidHardwareBufferFormatProperties2ANDROID::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 AndroidHardwareBufferFormatProperties2ANDROID::initialize(const AndroidHardwareBufferFormatProperties2ANDROID* 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
+
+PhysicalDeviceShaderEnqueueFeaturesAMDX::PhysicalDeviceShaderEnqueueFeaturesAMDX(
+    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);
+    }
+}
+
+PhysicalDeviceShaderEnqueueFeaturesAMDX::PhysicalDeviceShaderEnqueueFeaturesAMDX()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX), pNext(nullptr), shaderEnqueue() {}
+
+PhysicalDeviceShaderEnqueueFeaturesAMDX::PhysicalDeviceShaderEnqueueFeaturesAMDX(
+    const PhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src) {
+    sType = copy_src.sType;
+    shaderEnqueue = copy_src.shaderEnqueue;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderEnqueueFeaturesAMDX& PhysicalDeviceShaderEnqueueFeaturesAMDX::operator=(
+    const PhysicalDeviceShaderEnqueueFeaturesAMDX& 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;
+}
+
+PhysicalDeviceShaderEnqueueFeaturesAMDX::~PhysicalDeviceShaderEnqueueFeaturesAMDX() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderEnqueueFeaturesAMDX::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 PhysicalDeviceShaderEnqueueFeaturesAMDX::initialize(const PhysicalDeviceShaderEnqueueFeaturesAMDX* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderEnqueue = copy_src->shaderEnqueue;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderEnqueuePropertiesAMDX::PhysicalDeviceShaderEnqueuePropertiesAMDX(
+    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);
+    }
+}
+
+PhysicalDeviceShaderEnqueuePropertiesAMDX::PhysicalDeviceShaderEnqueuePropertiesAMDX()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX),
+      pNext(nullptr),
+      maxExecutionGraphDepth(),
+      maxExecutionGraphShaderOutputNodes(),
+      maxExecutionGraphShaderPayloadSize(),
+      maxExecutionGraphShaderPayloadCount(),
+      executionGraphDispatchAddressAlignment() {}
+
+PhysicalDeviceShaderEnqueuePropertiesAMDX::PhysicalDeviceShaderEnqueuePropertiesAMDX(
+    const PhysicalDeviceShaderEnqueuePropertiesAMDX& 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);
+}
+
+PhysicalDeviceShaderEnqueuePropertiesAMDX& PhysicalDeviceShaderEnqueuePropertiesAMDX::operator=(
+    const PhysicalDeviceShaderEnqueuePropertiesAMDX& 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;
+}
+
+PhysicalDeviceShaderEnqueuePropertiesAMDX::~PhysicalDeviceShaderEnqueuePropertiesAMDX() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderEnqueuePropertiesAMDX::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 PhysicalDeviceShaderEnqueuePropertiesAMDX::initialize(const PhysicalDeviceShaderEnqueuePropertiesAMDX* 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);
+}
+
+ExecutionGraphPipelineScratchSizeAMDX::ExecutionGraphPipelineScratchSizeAMDX(
+    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);
+    }
+}
+
+ExecutionGraphPipelineScratchSizeAMDX::ExecutionGraphPipelineScratchSizeAMDX()
+    : sType(VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX), pNext(nullptr), size() {}
+
+ExecutionGraphPipelineScratchSizeAMDX::ExecutionGraphPipelineScratchSizeAMDX(
+    const ExecutionGraphPipelineScratchSizeAMDX& copy_src) {
+    sType = copy_src.sType;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExecutionGraphPipelineScratchSizeAMDX& ExecutionGraphPipelineScratchSizeAMDX::operator=(
+    const ExecutionGraphPipelineScratchSizeAMDX& 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;
+}
+
+ExecutionGraphPipelineScratchSizeAMDX::~ExecutionGraphPipelineScratchSizeAMDX() { FreePnextChain(pNext); }
+
+void ExecutionGraphPipelineScratchSizeAMDX::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 ExecutionGraphPipelineScratchSizeAMDX::initialize(const ExecutionGraphPipelineScratchSizeAMDX* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ExecutionGraphPipelineCreateInfoAMDX::ExecutionGraphPipelineCreateInfoAMDX(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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pLibraryInfo) pLibraryInfo = new PipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo);
+}
+
+ExecutionGraphPipelineCreateInfoAMDX::ExecutionGraphPipelineCreateInfoAMDX()
+    : sType(VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX),
+      pNext(nullptr),
+      flags(),
+      stageCount(),
+      pStages(nullptr),
+      pLibraryInfo(nullptr),
+      layout(),
+      basePipelineHandle(),
+      basePipelineIndex() {}
+
+ExecutionGraphPipelineCreateInfoAMDX::ExecutionGraphPipelineCreateInfoAMDX(const ExecutionGraphPipelineCreateInfoAMDX& 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pLibraryInfo) pLibraryInfo = new PipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo);
+}
+
+ExecutionGraphPipelineCreateInfoAMDX& ExecutionGraphPipelineCreateInfoAMDX::operator=(
+    const ExecutionGraphPipelineCreateInfoAMDX& 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pLibraryInfo) pLibraryInfo = new PipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo);
+
+    return *this;
+}
+
+ExecutionGraphPipelineCreateInfoAMDX::~ExecutionGraphPipelineCreateInfoAMDX() {
+    if (pStages) delete[] pStages;
+    if (pLibraryInfo) delete pLibraryInfo;
+    FreePnextChain(pNext);
+}
+
+void ExecutionGraphPipelineCreateInfoAMDX::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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pLibraryInfo) pLibraryInfo = new PipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo);
+}
+
+void ExecutionGraphPipelineCreateInfoAMDX::initialize(const ExecutionGraphPipelineCreateInfoAMDX* 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src->pStages[i]);
+        }
+    }
+    if (copy_src->pLibraryInfo) pLibraryInfo = new PipelineLibraryCreateInfoKHR(*copy_src->pLibraryInfo);
+}
+
+DeviceOrHostAddressConstAMDX::DeviceOrHostAddressConstAMDX(const VkDeviceOrHostAddressConstAMDX* in_struct, PNextCopyState*) {
+    initialize(in_struct);
+}
+
+DeviceOrHostAddressConstAMDX::DeviceOrHostAddressConstAMDX() : hostAddress(nullptr) {}
+
+DeviceOrHostAddressConstAMDX::DeviceOrHostAddressConstAMDX(const DeviceOrHostAddressConstAMDX& copy_src) {
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+}
+
+DeviceOrHostAddressConstAMDX& DeviceOrHostAddressConstAMDX::operator=(const DeviceOrHostAddressConstAMDX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+
+    return *this;
+}
+
+DeviceOrHostAddressConstAMDX::~DeviceOrHostAddressConstAMDX() {}
+
+void DeviceOrHostAddressConstAMDX::initialize(const VkDeviceOrHostAddressConstAMDX* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = in_struct->deviceAddress;
+    hostAddress = in_struct->hostAddress;
+}
+
+void DeviceOrHostAddressConstAMDX::initialize(const DeviceOrHostAddressConstAMDX* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = copy_src->deviceAddress;
+    hostAddress = copy_src->hostAddress;
+}
+
+PipelineShaderStageNodeCreateInfoAMDX::PipelineShaderStageNodeCreateInfoAMDX(
+    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);
+}
+
+PipelineShaderStageNodeCreateInfoAMDX::PipelineShaderStageNodeCreateInfoAMDX()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX), pNext(nullptr), pName(nullptr), index() {}
+
+PipelineShaderStageNodeCreateInfoAMDX::PipelineShaderStageNodeCreateInfoAMDX(
+    const PipelineShaderStageNodeCreateInfoAMDX& copy_src) {
+    sType = copy_src.sType;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+}
+
+PipelineShaderStageNodeCreateInfoAMDX& PipelineShaderStageNodeCreateInfoAMDX::operator=(
+    const PipelineShaderStageNodeCreateInfoAMDX& 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;
+}
+
+PipelineShaderStageNodeCreateInfoAMDX::~PipelineShaderStageNodeCreateInfoAMDX() {
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+}
+
+void PipelineShaderStageNodeCreateInfoAMDX::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 PipelineShaderStageNodeCreateInfoAMDX::initialize(const PipelineShaderStageNodeCreateInfoAMDX* 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
+
+PipelineCoverageToColorStateCreateInfoNV::PipelineCoverageToColorStateCreateInfoNV(
+    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);
+    }
+}
+
+PipelineCoverageToColorStateCreateInfoNV::PipelineCoverageToColorStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      flags(),
+      coverageToColorEnable(),
+      coverageToColorLocation() {}
+
+PipelineCoverageToColorStateCreateInfoNV::PipelineCoverageToColorStateCreateInfoNV(
+    const PipelineCoverageToColorStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    coverageToColorEnable = copy_src.coverageToColorEnable;
+    coverageToColorLocation = copy_src.coverageToColorLocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineCoverageToColorStateCreateInfoNV& PipelineCoverageToColorStateCreateInfoNV::operator=(
+    const PipelineCoverageToColorStateCreateInfoNV& 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;
+}
+
+PipelineCoverageToColorStateCreateInfoNV::~PipelineCoverageToColorStateCreateInfoNV() { FreePnextChain(pNext); }
+
+void PipelineCoverageToColorStateCreateInfoNV::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 PipelineCoverageToColorStateCreateInfoNV::initialize(const PipelineCoverageToColorStateCreateInfoNV* 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);
+}
+
+PipelineCoverageModulationStateCreateInfoNV::PipelineCoverageModulationStateCreateInfoNV(
+    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);
+    }
+}
+
+PipelineCoverageModulationStateCreateInfoNV::PipelineCoverageModulationStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      flags(),
+      coverageModulationMode(),
+      coverageModulationTableEnable(),
+      coverageModulationTableCount(),
+      pCoverageModulationTable(nullptr) {}
+
+PipelineCoverageModulationStateCreateInfoNV::PipelineCoverageModulationStateCreateInfoNV(
+    const PipelineCoverageModulationStateCreateInfoNV& 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);
+    }
+}
+
+PipelineCoverageModulationStateCreateInfoNV& PipelineCoverageModulationStateCreateInfoNV::operator=(
+    const PipelineCoverageModulationStateCreateInfoNV& 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;
+}
+
+PipelineCoverageModulationStateCreateInfoNV::~PipelineCoverageModulationStateCreateInfoNV() {
+    if (pCoverageModulationTable) delete[] pCoverageModulationTable;
+    FreePnextChain(pNext);
+}
+
+void PipelineCoverageModulationStateCreateInfoNV::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 PipelineCoverageModulationStateCreateInfoNV::initialize(const PipelineCoverageModulationStateCreateInfoNV* 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);
+    }
+}
+
+PhysicalDeviceShaderSMBuiltinsPropertiesNV::PhysicalDeviceShaderSMBuiltinsPropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceShaderSMBuiltinsPropertiesNV::PhysicalDeviceShaderSMBuiltinsPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV),
+      pNext(nullptr),
+      shaderSMCount(),
+      shaderWarpsPerSM() {}
+
+PhysicalDeviceShaderSMBuiltinsPropertiesNV::PhysicalDeviceShaderSMBuiltinsPropertiesNV(
+    const PhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    shaderSMCount = copy_src.shaderSMCount;
+    shaderWarpsPerSM = copy_src.shaderWarpsPerSM;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderSMBuiltinsPropertiesNV& PhysicalDeviceShaderSMBuiltinsPropertiesNV::operator=(
+    const PhysicalDeviceShaderSMBuiltinsPropertiesNV& 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;
+}
+
+PhysicalDeviceShaderSMBuiltinsPropertiesNV::~PhysicalDeviceShaderSMBuiltinsPropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderSMBuiltinsPropertiesNV::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 PhysicalDeviceShaderSMBuiltinsPropertiesNV::initialize(const PhysicalDeviceShaderSMBuiltinsPropertiesNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSMCount = copy_src->shaderSMCount;
+    shaderWarpsPerSM = copy_src->shaderWarpsPerSM;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderSMBuiltinsFeaturesNV::PhysicalDeviceShaderSMBuiltinsFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceShaderSMBuiltinsFeaturesNV::PhysicalDeviceShaderSMBuiltinsFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV), pNext(nullptr), shaderSMBuiltins() {}
+
+PhysicalDeviceShaderSMBuiltinsFeaturesNV::PhysicalDeviceShaderSMBuiltinsFeaturesNV(
+    const PhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    shaderSMBuiltins = copy_src.shaderSMBuiltins;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderSMBuiltinsFeaturesNV& PhysicalDeviceShaderSMBuiltinsFeaturesNV::operator=(
+    const PhysicalDeviceShaderSMBuiltinsFeaturesNV& 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;
+}
+
+PhysicalDeviceShaderSMBuiltinsFeaturesNV::~PhysicalDeviceShaderSMBuiltinsFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderSMBuiltinsFeaturesNV::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 PhysicalDeviceShaderSMBuiltinsFeaturesNV::initialize(const PhysicalDeviceShaderSMBuiltinsFeaturesNV* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSMBuiltins = copy_src->shaderSMBuiltins;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ShadingRatePaletteNV::ShadingRatePaletteNV(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);
+    }
+}
+
+ShadingRatePaletteNV::ShadingRatePaletteNV() : shadingRatePaletteEntryCount(), pShadingRatePaletteEntries(nullptr) {}
+
+ShadingRatePaletteNV::ShadingRatePaletteNV(const ShadingRatePaletteNV& 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);
+    }
+}
+
+ShadingRatePaletteNV& ShadingRatePaletteNV::operator=(const ShadingRatePaletteNV& 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;
+}
+
+ShadingRatePaletteNV::~ShadingRatePaletteNV() {
+    if (pShadingRatePaletteEntries) delete[] pShadingRatePaletteEntries;
+}
+
+void ShadingRatePaletteNV::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 ShadingRatePaletteNV::initialize(const ShadingRatePaletteNV* 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);
+    }
+}
+
+PipelineViewportShadingRateImageStateCreateInfoNV::PipelineViewportShadingRateImageStateCreateInfoNV(
+    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 ShadingRatePaletteNV[viewportCount];
+        for (uint32_t i = 0; i < viewportCount; ++i) {
+            pShadingRatePalettes[i].initialize(&in_struct->pShadingRatePalettes[i]);
+        }
+    }
+}
+
+PipelineViewportShadingRateImageStateCreateInfoNV::PipelineViewportShadingRateImageStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      shadingRateImageEnable(),
+      viewportCount(),
+      pShadingRatePalettes(nullptr) {}
+
+PipelineViewportShadingRateImageStateCreateInfoNV::PipelineViewportShadingRateImageStateCreateInfoNV(
+    const PipelineViewportShadingRateImageStateCreateInfoNV& 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 ShadingRatePaletteNV[viewportCount];
+        for (uint32_t i = 0; i < viewportCount; ++i) {
+            pShadingRatePalettes[i].initialize(&copy_src.pShadingRatePalettes[i]);
+        }
+    }
+}
+
+PipelineViewportShadingRateImageStateCreateInfoNV& PipelineViewportShadingRateImageStateCreateInfoNV::operator=(
+    const PipelineViewportShadingRateImageStateCreateInfoNV& 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 ShadingRatePaletteNV[viewportCount];
+        for (uint32_t i = 0; i < viewportCount; ++i) {
+            pShadingRatePalettes[i].initialize(&copy_src.pShadingRatePalettes[i]);
+        }
+    }
+
+    return *this;
+}
+
+PipelineViewportShadingRateImageStateCreateInfoNV::~PipelineViewportShadingRateImageStateCreateInfoNV() {
+    if (pShadingRatePalettes) delete[] pShadingRatePalettes;
+    FreePnextChain(pNext);
+}
+
+void PipelineViewportShadingRateImageStateCreateInfoNV::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 ShadingRatePaletteNV[viewportCount];
+        for (uint32_t i = 0; i < viewportCount; ++i) {
+            pShadingRatePalettes[i].initialize(&in_struct->pShadingRatePalettes[i]);
+        }
+    }
+}
+
+void PipelineViewportShadingRateImageStateCreateInfoNV::initialize(
+    const PipelineViewportShadingRateImageStateCreateInfoNV* 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 ShadingRatePaletteNV[viewportCount];
+        for (uint32_t i = 0; i < viewportCount; ++i) {
+            pShadingRatePalettes[i].initialize(&copy_src->pShadingRatePalettes[i]);
+        }
+    }
+}
+
+PhysicalDeviceShadingRateImageFeaturesNV::PhysicalDeviceShadingRateImageFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceShadingRateImageFeaturesNV::PhysicalDeviceShadingRateImageFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV),
+      pNext(nullptr),
+      shadingRateImage(),
+      shadingRateCoarseSampleOrder() {}
+
+PhysicalDeviceShadingRateImageFeaturesNV::PhysicalDeviceShadingRateImageFeaturesNV(
+    const PhysicalDeviceShadingRateImageFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    shadingRateImage = copy_src.shadingRateImage;
+    shadingRateCoarseSampleOrder = copy_src.shadingRateCoarseSampleOrder;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShadingRateImageFeaturesNV& PhysicalDeviceShadingRateImageFeaturesNV::operator=(
+    const PhysicalDeviceShadingRateImageFeaturesNV& 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;
+}
+
+PhysicalDeviceShadingRateImageFeaturesNV::~PhysicalDeviceShadingRateImageFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShadingRateImageFeaturesNV::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 PhysicalDeviceShadingRateImageFeaturesNV::initialize(const PhysicalDeviceShadingRateImageFeaturesNV* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shadingRateImage = copy_src->shadingRateImage;
+    shadingRateCoarseSampleOrder = copy_src->shadingRateCoarseSampleOrder;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShadingRateImagePropertiesNV::PhysicalDeviceShadingRateImagePropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceShadingRateImagePropertiesNV::PhysicalDeviceShadingRateImagePropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV),
+      pNext(nullptr),
+      shadingRateTexelSize(),
+      shadingRatePaletteSize(),
+      shadingRateMaxCoarseSamples() {}
+
+PhysicalDeviceShadingRateImagePropertiesNV::PhysicalDeviceShadingRateImagePropertiesNV(
+    const PhysicalDeviceShadingRateImagePropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    shadingRateTexelSize = copy_src.shadingRateTexelSize;
+    shadingRatePaletteSize = copy_src.shadingRatePaletteSize;
+    shadingRateMaxCoarseSamples = copy_src.shadingRateMaxCoarseSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShadingRateImagePropertiesNV& PhysicalDeviceShadingRateImagePropertiesNV::operator=(
+    const PhysicalDeviceShadingRateImagePropertiesNV& 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;
+}
+
+PhysicalDeviceShadingRateImagePropertiesNV::~PhysicalDeviceShadingRateImagePropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShadingRateImagePropertiesNV::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 PhysicalDeviceShadingRateImagePropertiesNV::initialize(const PhysicalDeviceShadingRateImagePropertiesNV* 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);
+}
+
+CoarseSampleOrderCustomNV::CoarseSampleOrderCustomNV(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);
+    }
+}
+
+CoarseSampleOrderCustomNV::CoarseSampleOrderCustomNV()
+    : shadingRate(), sampleCount(), sampleLocationCount(), pSampleLocations(nullptr) {}
+
+CoarseSampleOrderCustomNV::CoarseSampleOrderCustomNV(const CoarseSampleOrderCustomNV& 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);
+    }
+}
+
+CoarseSampleOrderCustomNV& CoarseSampleOrderCustomNV::operator=(const CoarseSampleOrderCustomNV& 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;
+}
+
+CoarseSampleOrderCustomNV::~CoarseSampleOrderCustomNV() {
+    if (pSampleLocations) delete[] pSampleLocations;
+}
+
+void CoarseSampleOrderCustomNV::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 CoarseSampleOrderCustomNV::initialize(const CoarseSampleOrderCustomNV* 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);
+    }
+}
+
+PipelineViewportCoarseSampleOrderStateCreateInfoNV::PipelineViewportCoarseSampleOrderStateCreateInfoNV(
+    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 CoarseSampleOrderCustomNV[customSampleOrderCount];
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
+            pCustomSampleOrders[i].initialize(&in_struct->pCustomSampleOrders[i]);
+        }
+    }
+}
+
+PipelineViewportCoarseSampleOrderStateCreateInfoNV::PipelineViewportCoarseSampleOrderStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      sampleOrderType(),
+      customSampleOrderCount(),
+      pCustomSampleOrders(nullptr) {}
+
+PipelineViewportCoarseSampleOrderStateCreateInfoNV::PipelineViewportCoarseSampleOrderStateCreateInfoNV(
+    const PipelineViewportCoarseSampleOrderStateCreateInfoNV& 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 CoarseSampleOrderCustomNV[customSampleOrderCount];
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
+            pCustomSampleOrders[i].initialize(&copy_src.pCustomSampleOrders[i]);
+        }
+    }
+}
+
+PipelineViewportCoarseSampleOrderStateCreateInfoNV& PipelineViewportCoarseSampleOrderStateCreateInfoNV::operator=(
+    const PipelineViewportCoarseSampleOrderStateCreateInfoNV& 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 CoarseSampleOrderCustomNV[customSampleOrderCount];
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
+            pCustomSampleOrders[i].initialize(&copy_src.pCustomSampleOrders[i]);
+        }
+    }
+
+    return *this;
+}
+
+PipelineViewportCoarseSampleOrderStateCreateInfoNV::~PipelineViewportCoarseSampleOrderStateCreateInfoNV() {
+    if (pCustomSampleOrders) delete[] pCustomSampleOrders;
+    FreePnextChain(pNext);
+}
+
+void PipelineViewportCoarseSampleOrderStateCreateInfoNV::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 CoarseSampleOrderCustomNV[customSampleOrderCount];
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
+            pCustomSampleOrders[i].initialize(&in_struct->pCustomSampleOrders[i]);
+        }
+    }
+}
+
+void PipelineViewportCoarseSampleOrderStateCreateInfoNV::initialize(
+    const PipelineViewportCoarseSampleOrderStateCreateInfoNV* 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 CoarseSampleOrderCustomNV[customSampleOrderCount];
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
+            pCustomSampleOrders[i].initialize(&copy_src->pCustomSampleOrders[i]);
+        }
+    }
+}
+
+RayTracingShaderGroupCreateInfoNV::RayTracingShaderGroupCreateInfoNV(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);
+    }
+}
+
+RayTracingShaderGroupCreateInfoNV::RayTracingShaderGroupCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV),
+      pNext(nullptr),
+      type(),
+      generalShader(),
+      closestHitShader(),
+      anyHitShader(),
+      intersectionShader() {}
+
+RayTracingShaderGroupCreateInfoNV::RayTracingShaderGroupCreateInfoNV(const RayTracingShaderGroupCreateInfoNV& 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);
+}
+
+RayTracingShaderGroupCreateInfoNV& RayTracingShaderGroupCreateInfoNV::operator=(const RayTracingShaderGroupCreateInfoNV& 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;
+}
+
+RayTracingShaderGroupCreateInfoNV::~RayTracingShaderGroupCreateInfoNV() { FreePnextChain(pNext); }
+
+void RayTracingShaderGroupCreateInfoNV::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 RayTracingShaderGroupCreateInfoNV::initialize(const RayTracingShaderGroupCreateInfoNV* 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);
+}
+
+RayTracingPipelineCreateInfoNV::RayTracingPipelineCreateInfoNV(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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (groupCount && in_struct->pGroups) {
+        pGroups = new RayTracingShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&in_struct->pGroups[i]);
+        }
+    }
+}
+
+RayTracingPipelineCreateInfoNV::RayTracingPipelineCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV),
+      pNext(nullptr),
+      flags(),
+      stageCount(),
+      pStages(nullptr),
+      groupCount(),
+      pGroups(nullptr),
+      maxRecursionDepth(),
+      layout(),
+      basePipelineHandle(),
+      basePipelineIndex() {}
+
+RayTracingPipelineCreateInfoNV::RayTracingPipelineCreateInfoNV(const RayTracingPipelineCreateInfoNV& 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (groupCount && copy_src.pGroups) {
+        pGroups = new RayTracingShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src.pGroups[i]);
+        }
+    }
+}
+
+RayTracingPipelineCreateInfoNV& RayTracingPipelineCreateInfoNV::operator=(const RayTracingPipelineCreateInfoNV& 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (groupCount && copy_src.pGroups) {
+        pGroups = new RayTracingShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src.pGroups[i]);
+        }
+    }
+
+    return *this;
+}
+
+RayTracingPipelineCreateInfoNV::~RayTracingPipelineCreateInfoNV() {
+    if (pStages) delete[] pStages;
+    if (pGroups) delete[] pGroups;
+    FreePnextChain(pNext);
+}
+
+void RayTracingPipelineCreateInfoNV::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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (groupCount && in_struct->pGroups) {
+        pGroups = new RayTracingShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&in_struct->pGroups[i]);
+        }
+    }
+}
+
+void RayTracingPipelineCreateInfoNV::initialize(const RayTracingPipelineCreateInfoNV* 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src->pStages[i]);
+        }
+    }
+    if (groupCount && copy_src->pGroups) {
+        pGroups = new RayTracingShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src->pGroups[i]);
+        }
+    }
+}
+
+GeometryTrianglesNV::GeometryTrianglesNV(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);
+    }
+}
+
+GeometryTrianglesNV::GeometryTrianglesNV()
+    : sType(VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV),
+      pNext(nullptr),
+      vertexData(),
+      vertexOffset(),
+      vertexCount(),
+      vertexStride(),
+      vertexFormat(),
+      indexData(),
+      indexOffset(),
+      indexCount(),
+      indexType(),
+      transformData(),
+      transformOffset() {}
+
+GeometryTrianglesNV::GeometryTrianglesNV(const GeometryTrianglesNV& 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);
+}
+
+GeometryTrianglesNV& GeometryTrianglesNV::operator=(const GeometryTrianglesNV& 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;
+}
+
+GeometryTrianglesNV::~GeometryTrianglesNV() { FreePnextChain(pNext); }
+
+void GeometryTrianglesNV::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 GeometryTrianglesNV::initialize(const GeometryTrianglesNV* 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);
+}
+
+GeometryAABBNV::GeometryAABBNV(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);
+    }
+}
+
+GeometryAABBNV::GeometryAABBNV()
+    : sType(VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV), pNext(nullptr), aabbData(), numAABBs(), stride(), offset() {}
+
+GeometryAABBNV::GeometryAABBNV(const GeometryAABBNV& 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);
+}
+
+GeometryAABBNV& GeometryAABBNV::operator=(const GeometryAABBNV& 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;
+}
+
+GeometryAABBNV::~GeometryAABBNV() { FreePnextChain(pNext); }
+
+void GeometryAABBNV::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 GeometryAABBNV::initialize(const GeometryAABBNV* 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);
+}
+
+GeometryNV::GeometryNV(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);
+    }
+}
+
+GeometryNV::GeometryNV() : sType(VK_STRUCTURE_TYPE_GEOMETRY_NV), pNext(nullptr), geometryType(), geometry(), flags() {}
+
+GeometryNV::GeometryNV(const GeometryNV& copy_src) {
+    sType = copy_src.sType;
+    geometryType = copy_src.geometryType;
+    geometry = copy_src.geometry;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+GeometryNV& GeometryNV::operator=(const GeometryNV& 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;
+}
+
+GeometryNV::~GeometryNV() { FreePnextChain(pNext); }
+
+void GeometryNV::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 GeometryNV::initialize(const GeometryNV* 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);
+}
+
+AccelerationStructureInfoNV::AccelerationStructureInfoNV(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 GeometryNV[geometryCount];
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            pGeometries[i].initialize(&in_struct->pGeometries[i]);
+        }
+    }
+}
+
+AccelerationStructureInfoNV::AccelerationStructureInfoNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV),
+      pNext(nullptr),
+      type(),
+      flags(),
+      instanceCount(),
+      geometryCount(),
+      pGeometries(nullptr) {}
+
+AccelerationStructureInfoNV::AccelerationStructureInfoNV(const AccelerationStructureInfoNV& 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 GeometryNV[geometryCount];
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            pGeometries[i].initialize(&copy_src.pGeometries[i]);
+        }
+    }
+}
+
+AccelerationStructureInfoNV& AccelerationStructureInfoNV::operator=(const AccelerationStructureInfoNV& 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 GeometryNV[geometryCount];
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            pGeometries[i].initialize(&copy_src.pGeometries[i]);
+        }
+    }
+
+    return *this;
+}
+
+AccelerationStructureInfoNV::~AccelerationStructureInfoNV() {
+    if (pGeometries) delete[] pGeometries;
+    FreePnextChain(pNext);
+}
+
+void AccelerationStructureInfoNV::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 GeometryNV[geometryCount];
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            pGeometries[i].initialize(&in_struct->pGeometries[i]);
+        }
+    }
+}
+
+void AccelerationStructureInfoNV::initialize(const AccelerationStructureInfoNV* 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 GeometryNV[geometryCount];
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            pGeometries[i].initialize(&copy_src->pGeometries[i]);
+        }
+    }
+}
+
+AccelerationStructureCreateInfoNV::AccelerationStructureCreateInfoNV(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);
+    }
+}
+
+AccelerationStructureCreateInfoNV::AccelerationStructureCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV), pNext(nullptr), compactedSize() {}
+
+AccelerationStructureCreateInfoNV::AccelerationStructureCreateInfoNV(const AccelerationStructureCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    compactedSize = copy_src.compactedSize;
+    info.initialize(&copy_src.info);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AccelerationStructureCreateInfoNV& AccelerationStructureCreateInfoNV::operator=(const AccelerationStructureCreateInfoNV& 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;
+}
+
+AccelerationStructureCreateInfoNV::~AccelerationStructureCreateInfoNV() { FreePnextChain(pNext); }
+
+void AccelerationStructureCreateInfoNV::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 AccelerationStructureCreateInfoNV::initialize(const AccelerationStructureCreateInfoNV* 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);
+}
+
+BindAccelerationStructureMemoryInfoNV::BindAccelerationStructureMemoryInfoNV(
+    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);
+    }
+}
+
+BindAccelerationStructureMemoryInfoNV::BindAccelerationStructureMemoryInfoNV()
+    : sType(VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV),
+      pNext(nullptr),
+      accelerationStructure(),
+      memory(),
+      memoryOffset(),
+      deviceIndexCount(),
+      pDeviceIndices(nullptr) {}
+
+BindAccelerationStructureMemoryInfoNV::BindAccelerationStructureMemoryInfoNV(
+    const BindAccelerationStructureMemoryInfoNV& 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);
+    }
+}
+
+BindAccelerationStructureMemoryInfoNV& BindAccelerationStructureMemoryInfoNV::operator=(
+    const BindAccelerationStructureMemoryInfoNV& 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;
+}
+
+BindAccelerationStructureMemoryInfoNV::~BindAccelerationStructureMemoryInfoNV() {
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    FreePnextChain(pNext);
+}
+
+void BindAccelerationStructureMemoryInfoNV::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 BindAccelerationStructureMemoryInfoNV::initialize(const BindAccelerationStructureMemoryInfoNV* 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);
+    }
+}
+
+WriteDescriptorSetAccelerationStructureNV::WriteDescriptorSetAccelerationStructureNV(
+    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];
+        }
+    }
+}
+
+WriteDescriptorSetAccelerationStructureNV::WriteDescriptorSetAccelerationStructureNV()
+    : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV),
+      pNext(nullptr),
+      accelerationStructureCount(),
+      pAccelerationStructures(nullptr) {}
+
+WriteDescriptorSetAccelerationStructureNV::WriteDescriptorSetAccelerationStructureNV(
+    const WriteDescriptorSetAccelerationStructureNV& 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];
+        }
+    }
+}
+
+WriteDescriptorSetAccelerationStructureNV& WriteDescriptorSetAccelerationStructureNV::operator=(
+    const WriteDescriptorSetAccelerationStructureNV& 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;
+}
+
+WriteDescriptorSetAccelerationStructureNV::~WriteDescriptorSetAccelerationStructureNV() {
+    if (pAccelerationStructures) delete[] pAccelerationStructures;
+    FreePnextChain(pNext);
+}
+
+void WriteDescriptorSetAccelerationStructureNV::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 WriteDescriptorSetAccelerationStructureNV::initialize(const WriteDescriptorSetAccelerationStructureNV* 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];
+        }
+    }
+}
+
+AccelerationStructureMemoryRequirementsInfoNV::AccelerationStructureMemoryRequirementsInfoNV(
+    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);
+    }
+}
+
+AccelerationStructureMemoryRequirementsInfoNV::AccelerationStructureMemoryRequirementsInfoNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV),
+      pNext(nullptr),
+      type(),
+      accelerationStructure() {}
+
+AccelerationStructureMemoryRequirementsInfoNV::AccelerationStructureMemoryRequirementsInfoNV(
+    const AccelerationStructureMemoryRequirementsInfoNV& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    accelerationStructure = copy_src.accelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AccelerationStructureMemoryRequirementsInfoNV& AccelerationStructureMemoryRequirementsInfoNV::operator=(
+    const AccelerationStructureMemoryRequirementsInfoNV& 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;
+}
+
+AccelerationStructureMemoryRequirementsInfoNV::~AccelerationStructureMemoryRequirementsInfoNV() { FreePnextChain(pNext); }
+
+void AccelerationStructureMemoryRequirementsInfoNV::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 AccelerationStructureMemoryRequirementsInfoNV::initialize(const AccelerationStructureMemoryRequirementsInfoNV* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    accelerationStructure = copy_src->accelerationStructure;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceRayTracingPropertiesNV::PhysicalDeviceRayTracingPropertiesNV(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);
+    }
+}
+
+PhysicalDeviceRayTracingPropertiesNV::PhysicalDeviceRayTracingPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV),
+      pNext(nullptr),
+      shaderGroupHandleSize(),
+      maxRecursionDepth(),
+      maxShaderGroupStride(),
+      shaderGroupBaseAlignment(),
+      maxGeometryCount(),
+      maxInstanceCount(),
+      maxTriangleCount(),
+      maxDescriptorSetAccelerationStructures() {}
+
+PhysicalDeviceRayTracingPropertiesNV::PhysicalDeviceRayTracingPropertiesNV(const PhysicalDeviceRayTracingPropertiesNV& 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);
+}
+
+PhysicalDeviceRayTracingPropertiesNV& PhysicalDeviceRayTracingPropertiesNV::operator=(
+    const PhysicalDeviceRayTracingPropertiesNV& 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;
+}
+
+PhysicalDeviceRayTracingPropertiesNV::~PhysicalDeviceRayTracingPropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRayTracingPropertiesNV::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 PhysicalDeviceRayTracingPropertiesNV::initialize(const PhysicalDeviceRayTracingPropertiesNV* 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);
+}
+
+PhysicalDeviceRepresentativeFragmentTestFeaturesNV::PhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceRepresentativeFragmentTestFeaturesNV::PhysicalDeviceRepresentativeFragmentTestFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV),
+      pNext(nullptr),
+      representativeFragmentTest() {}
+
+PhysicalDeviceRepresentativeFragmentTestFeaturesNV::PhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+    const PhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    representativeFragmentTest = copy_src.representativeFragmentTest;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRepresentativeFragmentTestFeaturesNV& PhysicalDeviceRepresentativeFragmentTestFeaturesNV::operator=(
+    const PhysicalDeviceRepresentativeFragmentTestFeaturesNV& 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;
+}
+
+PhysicalDeviceRepresentativeFragmentTestFeaturesNV::~PhysicalDeviceRepresentativeFragmentTestFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRepresentativeFragmentTestFeaturesNV::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 PhysicalDeviceRepresentativeFragmentTestFeaturesNV::initialize(
+    const PhysicalDeviceRepresentativeFragmentTestFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    representativeFragmentTest = copy_src->representativeFragmentTest;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineRepresentativeFragmentTestStateCreateInfoNV::PipelineRepresentativeFragmentTestStateCreateInfoNV(
+    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);
+    }
+}
+
+PipelineRepresentativeFragmentTestStateCreateInfoNV::PipelineRepresentativeFragmentTestStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      representativeFragmentTestEnable() {}
+
+PipelineRepresentativeFragmentTestStateCreateInfoNV::PipelineRepresentativeFragmentTestStateCreateInfoNV(
+    const PipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    representativeFragmentTestEnable = copy_src.representativeFragmentTestEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineRepresentativeFragmentTestStateCreateInfoNV& PipelineRepresentativeFragmentTestStateCreateInfoNV::operator=(
+    const PipelineRepresentativeFragmentTestStateCreateInfoNV& 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;
+}
+
+PipelineRepresentativeFragmentTestStateCreateInfoNV::~PipelineRepresentativeFragmentTestStateCreateInfoNV() {
+    FreePnextChain(pNext);
+}
+
+void PipelineRepresentativeFragmentTestStateCreateInfoNV::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 PipelineRepresentativeFragmentTestStateCreateInfoNV::initialize(
+    const PipelineRepresentativeFragmentTestStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    representativeFragmentTestEnable = copy_src->representativeFragmentTestEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineCompilerControlCreateInfoAMD::PipelineCompilerControlCreateInfoAMD(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);
+    }
+}
+
+PipelineCompilerControlCreateInfoAMD::PipelineCompilerControlCreateInfoAMD()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD), pNext(nullptr), compilerControlFlags() {}
+
+PipelineCompilerControlCreateInfoAMD::PipelineCompilerControlCreateInfoAMD(const PipelineCompilerControlCreateInfoAMD& copy_src) {
+    sType = copy_src.sType;
+    compilerControlFlags = copy_src.compilerControlFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineCompilerControlCreateInfoAMD& PipelineCompilerControlCreateInfoAMD::operator=(
+    const PipelineCompilerControlCreateInfoAMD& 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;
+}
+
+PipelineCompilerControlCreateInfoAMD::~PipelineCompilerControlCreateInfoAMD() { FreePnextChain(pNext); }
+
+void PipelineCompilerControlCreateInfoAMD::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 PipelineCompilerControlCreateInfoAMD::initialize(const PipelineCompilerControlCreateInfoAMD* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    compilerControlFlags = copy_src->compilerControlFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderCorePropertiesAMD::PhysicalDeviceShaderCorePropertiesAMD(
+    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);
+    }
+}
+
+PhysicalDeviceShaderCorePropertiesAMD::PhysicalDeviceShaderCorePropertiesAMD()
+    : 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() {}
+
+PhysicalDeviceShaderCorePropertiesAMD::PhysicalDeviceShaderCorePropertiesAMD(
+    const PhysicalDeviceShaderCorePropertiesAMD& 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);
+}
+
+PhysicalDeviceShaderCorePropertiesAMD& PhysicalDeviceShaderCorePropertiesAMD::operator=(
+    const PhysicalDeviceShaderCorePropertiesAMD& 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;
+}
+
+PhysicalDeviceShaderCorePropertiesAMD::~PhysicalDeviceShaderCorePropertiesAMD() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderCorePropertiesAMD::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 PhysicalDeviceShaderCorePropertiesAMD::initialize(const PhysicalDeviceShaderCorePropertiesAMD* 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);
+}
+
+DeviceMemoryOverallocationCreateInfoAMD::DeviceMemoryOverallocationCreateInfoAMD(
+    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);
+    }
+}
+
+DeviceMemoryOverallocationCreateInfoAMD::DeviceMemoryOverallocationCreateInfoAMD()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD), pNext(nullptr), overallocationBehavior() {}
+
+DeviceMemoryOverallocationCreateInfoAMD::DeviceMemoryOverallocationCreateInfoAMD(
+    const DeviceMemoryOverallocationCreateInfoAMD& copy_src) {
+    sType = copy_src.sType;
+    overallocationBehavior = copy_src.overallocationBehavior;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceMemoryOverallocationCreateInfoAMD& DeviceMemoryOverallocationCreateInfoAMD::operator=(
+    const DeviceMemoryOverallocationCreateInfoAMD& 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;
+}
+
+DeviceMemoryOverallocationCreateInfoAMD::~DeviceMemoryOverallocationCreateInfoAMD() { FreePnextChain(pNext); }
+
+void DeviceMemoryOverallocationCreateInfoAMD::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 DeviceMemoryOverallocationCreateInfoAMD::initialize(const DeviceMemoryOverallocationCreateInfoAMD* 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
+
+PresentFrameTokenGGP::PresentFrameTokenGGP(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);
+    }
+}
+
+PresentFrameTokenGGP::PresentFrameTokenGGP() : sType(VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP), pNext(nullptr), frameToken() {}
+
+PresentFrameTokenGGP::PresentFrameTokenGGP(const PresentFrameTokenGGP& copy_src) {
+    sType = copy_src.sType;
+    frameToken = copy_src.frameToken;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PresentFrameTokenGGP& PresentFrameTokenGGP::operator=(const PresentFrameTokenGGP& 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;
+}
+
+PresentFrameTokenGGP::~PresentFrameTokenGGP() { FreePnextChain(pNext); }
+
+void PresentFrameTokenGGP::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 PresentFrameTokenGGP::initialize(const PresentFrameTokenGGP* 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
+
+PhysicalDeviceComputeShaderDerivativesFeaturesNV::PhysicalDeviceComputeShaderDerivativesFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceComputeShaderDerivativesFeaturesNV::PhysicalDeviceComputeShaderDerivativesFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV),
+      pNext(nullptr),
+      computeDerivativeGroupQuads(),
+      computeDerivativeGroupLinear() {}
+
+PhysicalDeviceComputeShaderDerivativesFeaturesNV::PhysicalDeviceComputeShaderDerivativesFeaturesNV(
+    const PhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads;
+    computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceComputeShaderDerivativesFeaturesNV& PhysicalDeviceComputeShaderDerivativesFeaturesNV::operator=(
+    const PhysicalDeviceComputeShaderDerivativesFeaturesNV& 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;
+}
+
+PhysicalDeviceComputeShaderDerivativesFeaturesNV::~PhysicalDeviceComputeShaderDerivativesFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceComputeShaderDerivativesFeaturesNV::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 PhysicalDeviceComputeShaderDerivativesFeaturesNV::initialize(const PhysicalDeviceComputeShaderDerivativesFeaturesNV* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    computeDerivativeGroupQuads = copy_src->computeDerivativeGroupQuads;
+    computeDerivativeGroupLinear = copy_src->computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMeshShaderFeaturesNV::PhysicalDeviceMeshShaderFeaturesNV(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);
+    }
+}
+
+PhysicalDeviceMeshShaderFeaturesNV::PhysicalDeviceMeshShaderFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV), pNext(nullptr), taskShader(), meshShader() {}
+
+PhysicalDeviceMeshShaderFeaturesNV::PhysicalDeviceMeshShaderFeaturesNV(const PhysicalDeviceMeshShaderFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    taskShader = copy_src.taskShader;
+    meshShader = copy_src.meshShader;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMeshShaderFeaturesNV& PhysicalDeviceMeshShaderFeaturesNV::operator=(
+    const PhysicalDeviceMeshShaderFeaturesNV& 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;
+}
+
+PhysicalDeviceMeshShaderFeaturesNV::~PhysicalDeviceMeshShaderFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMeshShaderFeaturesNV::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 PhysicalDeviceMeshShaderFeaturesNV::initialize(const PhysicalDeviceMeshShaderFeaturesNV* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    taskShader = copy_src->taskShader;
+    meshShader = copy_src->meshShader;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMeshShaderPropertiesNV::PhysicalDeviceMeshShaderPropertiesNV(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];
+    }
+}
+
+PhysicalDeviceMeshShaderPropertiesNV::PhysicalDeviceMeshShaderPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV),
+      pNext(nullptr),
+      maxDrawMeshTasksCount(),
+      maxTaskWorkGroupInvocations(),
+      maxTaskTotalMemorySize(),
+      maxTaskOutputCount(),
+      maxMeshWorkGroupInvocations(),
+      maxMeshTotalMemorySize(),
+      maxMeshOutputVertices(),
+      maxMeshOutputPrimitives(),
+      maxMeshMultiviewViewCount(),
+      meshOutputPerVertexGranularity(),
+      meshOutputPerPrimitiveGranularity() {}
+
+PhysicalDeviceMeshShaderPropertiesNV::PhysicalDeviceMeshShaderPropertiesNV(const PhysicalDeviceMeshShaderPropertiesNV& 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];
+    }
+}
+
+PhysicalDeviceMeshShaderPropertiesNV& PhysicalDeviceMeshShaderPropertiesNV::operator=(
+    const PhysicalDeviceMeshShaderPropertiesNV& 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;
+}
+
+PhysicalDeviceMeshShaderPropertiesNV::~PhysicalDeviceMeshShaderPropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMeshShaderPropertiesNV::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 PhysicalDeviceMeshShaderPropertiesNV::initialize(const PhysicalDeviceMeshShaderPropertiesNV* 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];
+    }
+}
+
+PhysicalDeviceShaderImageFootprintFeaturesNV::PhysicalDeviceShaderImageFootprintFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceShaderImageFootprintFeaturesNV::PhysicalDeviceShaderImageFootprintFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV), pNext(nullptr), imageFootprint() {}
+
+PhysicalDeviceShaderImageFootprintFeaturesNV::PhysicalDeviceShaderImageFootprintFeaturesNV(
+    const PhysicalDeviceShaderImageFootprintFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    imageFootprint = copy_src.imageFootprint;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderImageFootprintFeaturesNV& PhysicalDeviceShaderImageFootprintFeaturesNV::operator=(
+    const PhysicalDeviceShaderImageFootprintFeaturesNV& 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;
+}
+
+PhysicalDeviceShaderImageFootprintFeaturesNV::~PhysicalDeviceShaderImageFootprintFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderImageFootprintFeaturesNV::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 PhysicalDeviceShaderImageFootprintFeaturesNV::initialize(const PhysicalDeviceShaderImageFootprintFeaturesNV* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageFootprint = copy_src->imageFootprint;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineViewportExclusiveScissorStateCreateInfoNV::PipelineViewportExclusiveScissorStateCreateInfoNV(
+    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);
+    }
+}
+
+PipelineViewportExclusiveScissorStateCreateInfoNV::PipelineViewportExclusiveScissorStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      exclusiveScissorCount(),
+      pExclusiveScissors(nullptr) {}
+
+PipelineViewportExclusiveScissorStateCreateInfoNV::PipelineViewportExclusiveScissorStateCreateInfoNV(
+    const PipelineViewportExclusiveScissorStateCreateInfoNV& 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);
+    }
+}
+
+PipelineViewportExclusiveScissorStateCreateInfoNV& PipelineViewportExclusiveScissorStateCreateInfoNV::operator=(
+    const PipelineViewportExclusiveScissorStateCreateInfoNV& 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;
+}
+
+PipelineViewportExclusiveScissorStateCreateInfoNV::~PipelineViewportExclusiveScissorStateCreateInfoNV() {
+    if (pExclusiveScissors) delete[] pExclusiveScissors;
+    FreePnextChain(pNext);
+}
+
+void PipelineViewportExclusiveScissorStateCreateInfoNV::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 PipelineViewportExclusiveScissorStateCreateInfoNV::initialize(
+    const PipelineViewportExclusiveScissorStateCreateInfoNV* 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);
+    }
+}
+
+PhysicalDeviceExclusiveScissorFeaturesNV::PhysicalDeviceExclusiveScissorFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceExclusiveScissorFeaturesNV::PhysicalDeviceExclusiveScissorFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV), pNext(nullptr), exclusiveScissor() {}
+
+PhysicalDeviceExclusiveScissorFeaturesNV::PhysicalDeviceExclusiveScissorFeaturesNV(
+    const PhysicalDeviceExclusiveScissorFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    exclusiveScissor = copy_src.exclusiveScissor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExclusiveScissorFeaturesNV& PhysicalDeviceExclusiveScissorFeaturesNV::operator=(
+    const PhysicalDeviceExclusiveScissorFeaturesNV& 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;
+}
+
+PhysicalDeviceExclusiveScissorFeaturesNV::~PhysicalDeviceExclusiveScissorFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExclusiveScissorFeaturesNV::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 PhysicalDeviceExclusiveScissorFeaturesNV::initialize(const PhysicalDeviceExclusiveScissorFeaturesNV* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    exclusiveScissor = copy_src->exclusiveScissor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+QueueFamilyCheckpointPropertiesNV::QueueFamilyCheckpointPropertiesNV(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);
+    }
+}
+
+QueueFamilyCheckpointPropertiesNV::QueueFamilyCheckpointPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV), pNext(nullptr), checkpointExecutionStageMask() {}
+
+QueueFamilyCheckpointPropertiesNV::QueueFamilyCheckpointPropertiesNV(const QueueFamilyCheckpointPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+QueueFamilyCheckpointPropertiesNV& QueueFamilyCheckpointPropertiesNV::operator=(const QueueFamilyCheckpointPropertiesNV& 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;
+}
+
+QueueFamilyCheckpointPropertiesNV::~QueueFamilyCheckpointPropertiesNV() { FreePnextChain(pNext); }
+
+void QueueFamilyCheckpointPropertiesNV::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 QueueFamilyCheckpointPropertiesNV::initialize(const QueueFamilyCheckpointPropertiesNV* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    checkpointExecutionStageMask = copy_src->checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CheckpointDataNV::CheckpointDataNV(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);
+    }
+}
+
+CheckpointDataNV::CheckpointDataNV()
+    : sType(VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV), pNext(nullptr), stage(), pCheckpointMarker(nullptr) {}
+
+CheckpointDataNV::CheckpointDataNV(const CheckpointDataNV& copy_src) {
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    pCheckpointMarker = copy_src.pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CheckpointDataNV& CheckpointDataNV::operator=(const CheckpointDataNV& 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;
+}
+
+CheckpointDataNV::~CheckpointDataNV() { FreePnextChain(pNext); }
+
+void CheckpointDataNV::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 CheckpointDataNV::initialize(const CheckpointDataNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stage = copy_src->stage;
+    pCheckpointMarker = copy_src->pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+    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);
+    }
+}
+
+PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL),
+      pNext(nullptr),
+      shaderIntegerFunctions2() {}
+
+PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+    const PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src) {
+    sType = copy_src.sType;
+    shaderIntegerFunctions2 = copy_src.shaderIntegerFunctions2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::operator=(
+    const PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& 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;
+}
+
+PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::~PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::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 PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::initialize(
+    const PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderIntegerFunctions2 = copy_src->shaderIntegerFunctions2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PerformanceValueDataINTEL::PerformanceValueDataINTEL(const VkPerformanceValueDataINTEL* in_struct, PNextCopyState*) {
+    initialize(in_struct);
+}
+
+PerformanceValueDataINTEL::PerformanceValueDataINTEL() : valueString(nullptr) {}
+
+PerformanceValueDataINTEL::PerformanceValueDataINTEL(const PerformanceValueDataINTEL& copy_src) {
+    value32 = copy_src.value32;
+    value64 = copy_src.value64;
+    valueFloat = copy_src.valueFloat;
+    valueBool = copy_src.valueBool;
+    valueString = SafeStringCopy(copy_src.valueString);
+}
+
+PerformanceValueDataINTEL& PerformanceValueDataINTEL::operator=(const PerformanceValueDataINTEL& 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;
+}
+
+PerformanceValueDataINTEL::~PerformanceValueDataINTEL() {
+    if (valueString) delete[] valueString;
+}
+
+void PerformanceValueDataINTEL::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 PerformanceValueDataINTEL::initialize(const PerformanceValueDataINTEL* 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);
+}
+
+InitializePerformanceApiInfoINTEL::InitializePerformanceApiInfoINTEL(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);
+    }
+}
+
+InitializePerformanceApiInfoINTEL::InitializePerformanceApiInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL), pNext(nullptr), pUserData(nullptr) {}
+
+InitializePerformanceApiInfoINTEL::InitializePerformanceApiInfoINTEL(const InitializePerformanceApiInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    pUserData = copy_src.pUserData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+InitializePerformanceApiInfoINTEL& InitializePerformanceApiInfoINTEL::operator=(const InitializePerformanceApiInfoINTEL& 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;
+}
+
+InitializePerformanceApiInfoINTEL::~InitializePerformanceApiInfoINTEL() { FreePnextChain(pNext); }
+
+void InitializePerformanceApiInfoINTEL::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 InitializePerformanceApiInfoINTEL::initialize(const InitializePerformanceApiInfoINTEL* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pUserData = copy_src->pUserData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+QueryPoolPerformanceQueryCreateInfoINTEL::QueryPoolPerformanceQueryCreateInfoINTEL(
+    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);
+    }
+}
+
+QueryPoolPerformanceQueryCreateInfoINTEL::QueryPoolPerformanceQueryCreateInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL), pNext(nullptr), performanceCountersSampling() {}
+
+QueryPoolPerformanceQueryCreateInfoINTEL::QueryPoolPerformanceQueryCreateInfoINTEL(
+    const QueryPoolPerformanceQueryCreateInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    performanceCountersSampling = copy_src.performanceCountersSampling;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+QueryPoolPerformanceQueryCreateInfoINTEL& QueryPoolPerformanceQueryCreateInfoINTEL::operator=(
+    const QueryPoolPerformanceQueryCreateInfoINTEL& 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;
+}
+
+QueryPoolPerformanceQueryCreateInfoINTEL::~QueryPoolPerformanceQueryCreateInfoINTEL() { FreePnextChain(pNext); }
+
+void QueryPoolPerformanceQueryCreateInfoINTEL::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 QueryPoolPerformanceQueryCreateInfoINTEL::initialize(const QueryPoolPerformanceQueryCreateInfoINTEL* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    performanceCountersSampling = copy_src->performanceCountersSampling;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PerformanceMarkerInfoINTEL::PerformanceMarkerInfoINTEL(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);
+    }
+}
+
+PerformanceMarkerInfoINTEL::PerformanceMarkerInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL), pNext(nullptr), marker() {}
+
+PerformanceMarkerInfoINTEL::PerformanceMarkerInfoINTEL(const PerformanceMarkerInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    marker = copy_src.marker;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PerformanceMarkerInfoINTEL& PerformanceMarkerInfoINTEL::operator=(const PerformanceMarkerInfoINTEL& 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;
+}
+
+PerformanceMarkerInfoINTEL::~PerformanceMarkerInfoINTEL() { FreePnextChain(pNext); }
+
+void PerformanceMarkerInfoINTEL::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 PerformanceMarkerInfoINTEL::initialize(const PerformanceMarkerInfoINTEL* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    marker = copy_src->marker;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PerformanceStreamMarkerInfoINTEL::PerformanceStreamMarkerInfoINTEL(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);
+    }
+}
+
+PerformanceStreamMarkerInfoINTEL::PerformanceStreamMarkerInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL), pNext(nullptr), marker() {}
+
+PerformanceStreamMarkerInfoINTEL::PerformanceStreamMarkerInfoINTEL(const PerformanceStreamMarkerInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    marker = copy_src.marker;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PerformanceStreamMarkerInfoINTEL& PerformanceStreamMarkerInfoINTEL::operator=(const PerformanceStreamMarkerInfoINTEL& 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;
+}
+
+PerformanceStreamMarkerInfoINTEL::~PerformanceStreamMarkerInfoINTEL() { FreePnextChain(pNext); }
+
+void PerformanceStreamMarkerInfoINTEL::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 PerformanceStreamMarkerInfoINTEL::initialize(const PerformanceStreamMarkerInfoINTEL* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    marker = copy_src->marker;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PerformanceOverrideInfoINTEL::PerformanceOverrideInfoINTEL(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);
+    }
+}
+
+PerformanceOverrideInfoINTEL::PerformanceOverrideInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL), pNext(nullptr), type(), enable(), parameter() {}
+
+PerformanceOverrideInfoINTEL::PerformanceOverrideInfoINTEL(const PerformanceOverrideInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    enable = copy_src.enable;
+    parameter = copy_src.parameter;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PerformanceOverrideInfoINTEL& PerformanceOverrideInfoINTEL::operator=(const PerformanceOverrideInfoINTEL& 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;
+}
+
+PerformanceOverrideInfoINTEL::~PerformanceOverrideInfoINTEL() { FreePnextChain(pNext); }
+
+void PerformanceOverrideInfoINTEL::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 PerformanceOverrideInfoINTEL::initialize(const PerformanceOverrideInfoINTEL* 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);
+}
+
+PerformanceConfigurationAcquireInfoINTEL::PerformanceConfigurationAcquireInfoINTEL(
+    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);
+    }
+}
+
+PerformanceConfigurationAcquireInfoINTEL::PerformanceConfigurationAcquireInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL), pNext(nullptr), type() {}
+
+PerformanceConfigurationAcquireInfoINTEL::PerformanceConfigurationAcquireInfoINTEL(
+    const PerformanceConfigurationAcquireInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PerformanceConfigurationAcquireInfoINTEL& PerformanceConfigurationAcquireInfoINTEL::operator=(
+    const PerformanceConfigurationAcquireInfoINTEL& 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;
+}
+
+PerformanceConfigurationAcquireInfoINTEL::~PerformanceConfigurationAcquireInfoINTEL() { FreePnextChain(pNext); }
+
+void PerformanceConfigurationAcquireInfoINTEL::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 PerformanceConfigurationAcquireInfoINTEL::initialize(const PerformanceConfigurationAcquireInfoINTEL* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DisplayNativeHdrSurfaceCapabilitiesAMD::DisplayNativeHdrSurfaceCapabilitiesAMD(
+    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);
+    }
+}
+
+DisplayNativeHdrSurfaceCapabilitiesAMD::DisplayNativeHdrSurfaceCapabilitiesAMD()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD), pNext(nullptr), localDimmingSupport() {}
+
+DisplayNativeHdrSurfaceCapabilitiesAMD::DisplayNativeHdrSurfaceCapabilitiesAMD(
+    const DisplayNativeHdrSurfaceCapabilitiesAMD& copy_src) {
+    sType = copy_src.sType;
+    localDimmingSupport = copy_src.localDimmingSupport;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DisplayNativeHdrSurfaceCapabilitiesAMD& DisplayNativeHdrSurfaceCapabilitiesAMD::operator=(
+    const DisplayNativeHdrSurfaceCapabilitiesAMD& 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;
+}
+
+DisplayNativeHdrSurfaceCapabilitiesAMD::~DisplayNativeHdrSurfaceCapabilitiesAMD() { FreePnextChain(pNext); }
+
+void DisplayNativeHdrSurfaceCapabilitiesAMD::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 DisplayNativeHdrSurfaceCapabilitiesAMD::initialize(const DisplayNativeHdrSurfaceCapabilitiesAMD* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    localDimmingSupport = copy_src->localDimmingSupport;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SwapchainDisplayNativeHdrCreateInfoAMD::SwapchainDisplayNativeHdrCreateInfoAMD(
+    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);
+    }
+}
+
+SwapchainDisplayNativeHdrCreateInfoAMD::SwapchainDisplayNativeHdrCreateInfoAMD()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD), pNext(nullptr), localDimmingEnable() {}
+
+SwapchainDisplayNativeHdrCreateInfoAMD::SwapchainDisplayNativeHdrCreateInfoAMD(
+    const SwapchainDisplayNativeHdrCreateInfoAMD& copy_src) {
+    sType = copy_src.sType;
+    localDimmingEnable = copy_src.localDimmingEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SwapchainDisplayNativeHdrCreateInfoAMD& SwapchainDisplayNativeHdrCreateInfoAMD::operator=(
+    const SwapchainDisplayNativeHdrCreateInfoAMD& 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;
+}
+
+SwapchainDisplayNativeHdrCreateInfoAMD::~SwapchainDisplayNativeHdrCreateInfoAMD() { FreePnextChain(pNext); }
+
+void SwapchainDisplayNativeHdrCreateInfoAMD::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 SwapchainDisplayNativeHdrCreateInfoAMD::initialize(const SwapchainDisplayNativeHdrCreateInfoAMD* 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
+
+ImagePipeSurfaceCreateInfoFUCHSIA::ImagePipeSurfaceCreateInfoFUCHSIA(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);
+    }
+}
+
+ImagePipeSurfaceCreateInfoFUCHSIA::ImagePipeSurfaceCreateInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA), pNext(nullptr), flags(), imagePipeHandle() {}
+
+ImagePipeSurfaceCreateInfoFUCHSIA::ImagePipeSurfaceCreateInfoFUCHSIA(const ImagePipeSurfaceCreateInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    imagePipeHandle = copy_src.imagePipeHandle;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImagePipeSurfaceCreateInfoFUCHSIA& ImagePipeSurfaceCreateInfoFUCHSIA::operator=(const ImagePipeSurfaceCreateInfoFUCHSIA& 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;
+}
+
+ImagePipeSurfaceCreateInfoFUCHSIA::~ImagePipeSurfaceCreateInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void ImagePipeSurfaceCreateInfoFUCHSIA::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 ImagePipeSurfaceCreateInfoFUCHSIA::initialize(const ImagePipeSurfaceCreateInfoFUCHSIA* 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
+
+PhysicalDeviceShaderCoreProperties2AMD::PhysicalDeviceShaderCoreProperties2AMD(
+    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);
+    }
+}
+
+PhysicalDeviceShaderCoreProperties2AMD::PhysicalDeviceShaderCoreProperties2AMD()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD),
+      pNext(nullptr),
+      shaderCoreFeatures(),
+      activeComputeUnitCount() {}
+
+PhysicalDeviceShaderCoreProperties2AMD::PhysicalDeviceShaderCoreProperties2AMD(
+    const PhysicalDeviceShaderCoreProperties2AMD& copy_src) {
+    sType = copy_src.sType;
+    shaderCoreFeatures = copy_src.shaderCoreFeatures;
+    activeComputeUnitCount = copy_src.activeComputeUnitCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderCoreProperties2AMD& PhysicalDeviceShaderCoreProperties2AMD::operator=(
+    const PhysicalDeviceShaderCoreProperties2AMD& 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;
+}
+
+PhysicalDeviceShaderCoreProperties2AMD::~PhysicalDeviceShaderCoreProperties2AMD() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderCoreProperties2AMD::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 PhysicalDeviceShaderCoreProperties2AMD::initialize(const PhysicalDeviceShaderCoreProperties2AMD* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderCoreFeatures = copy_src->shaderCoreFeatures;
+    activeComputeUnitCount = copy_src->activeComputeUnitCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceCoherentMemoryFeaturesAMD::PhysicalDeviceCoherentMemoryFeaturesAMD(
+    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);
+    }
+}
+
+PhysicalDeviceCoherentMemoryFeaturesAMD::PhysicalDeviceCoherentMemoryFeaturesAMD()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD), pNext(nullptr), deviceCoherentMemory() {}
+
+PhysicalDeviceCoherentMemoryFeaturesAMD::PhysicalDeviceCoherentMemoryFeaturesAMD(
+    const PhysicalDeviceCoherentMemoryFeaturesAMD& copy_src) {
+    sType = copy_src.sType;
+    deviceCoherentMemory = copy_src.deviceCoherentMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCoherentMemoryFeaturesAMD& PhysicalDeviceCoherentMemoryFeaturesAMD::operator=(
+    const PhysicalDeviceCoherentMemoryFeaturesAMD& 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;
+}
+
+PhysicalDeviceCoherentMemoryFeaturesAMD::~PhysicalDeviceCoherentMemoryFeaturesAMD() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCoherentMemoryFeaturesAMD::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 PhysicalDeviceCoherentMemoryFeaturesAMD::initialize(const PhysicalDeviceCoherentMemoryFeaturesAMD* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceCoherentMemory = copy_src->deviceCoherentMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV),
+      pNext(nullptr),
+      dedicatedAllocationImageAliasing() {}
+
+PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+    const PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    dedicatedAllocationImageAliasing = copy_src.dedicatedAllocationImageAliasing;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::operator=(
+    const PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& 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;
+}
+
+PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::~PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::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 PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::initialize(
+    const PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dedicatedAllocationImageAliasing = copy_src->dedicatedAllocationImageAliasing;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CooperativeMatrixPropertiesNV::CooperativeMatrixPropertiesNV(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);
+    }
+}
+
+CooperativeMatrixPropertiesNV::CooperativeMatrixPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV),
+      pNext(nullptr),
+      MSize(),
+      NSize(),
+      KSize(),
+      AType(),
+      BType(),
+      CType(),
+      DType(),
+      scope() {}
+
+CooperativeMatrixPropertiesNV::CooperativeMatrixPropertiesNV(const CooperativeMatrixPropertiesNV& 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);
+}
+
+CooperativeMatrixPropertiesNV& CooperativeMatrixPropertiesNV::operator=(const CooperativeMatrixPropertiesNV& 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;
+}
+
+CooperativeMatrixPropertiesNV::~CooperativeMatrixPropertiesNV() { FreePnextChain(pNext); }
+
+void CooperativeMatrixPropertiesNV::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 CooperativeMatrixPropertiesNV::initialize(const CooperativeMatrixPropertiesNV* 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);
+}
+
+PhysicalDeviceCooperativeMatrixFeaturesNV::PhysicalDeviceCooperativeMatrixFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceCooperativeMatrixFeaturesNV::PhysicalDeviceCooperativeMatrixFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV),
+      pNext(nullptr),
+      cooperativeMatrix(),
+      cooperativeMatrixRobustBufferAccess() {}
+
+PhysicalDeviceCooperativeMatrixFeaturesNV::PhysicalDeviceCooperativeMatrixFeaturesNV(
+    const PhysicalDeviceCooperativeMatrixFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    cooperativeMatrix = copy_src.cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCooperativeMatrixFeaturesNV& PhysicalDeviceCooperativeMatrixFeaturesNV::operator=(
+    const PhysicalDeviceCooperativeMatrixFeaturesNV& 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;
+}
+
+PhysicalDeviceCooperativeMatrixFeaturesNV::~PhysicalDeviceCooperativeMatrixFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCooperativeMatrixFeaturesNV::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 PhysicalDeviceCooperativeMatrixFeaturesNV::initialize(const PhysicalDeviceCooperativeMatrixFeaturesNV* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeMatrix = copy_src->cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = copy_src->cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceCooperativeMatrixPropertiesNV::PhysicalDeviceCooperativeMatrixPropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceCooperativeMatrixPropertiesNV::PhysicalDeviceCooperativeMatrixPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV),
+      pNext(nullptr),
+      cooperativeMatrixSupportedStages() {}
+
+PhysicalDeviceCooperativeMatrixPropertiesNV::PhysicalDeviceCooperativeMatrixPropertiesNV(
+    const PhysicalDeviceCooperativeMatrixPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCooperativeMatrixPropertiesNV& PhysicalDeviceCooperativeMatrixPropertiesNV::operator=(
+    const PhysicalDeviceCooperativeMatrixPropertiesNV& 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;
+}
+
+PhysicalDeviceCooperativeMatrixPropertiesNV::~PhysicalDeviceCooperativeMatrixPropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCooperativeMatrixPropertiesNV::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 PhysicalDeviceCooperativeMatrixPropertiesNV::initialize(const PhysicalDeviceCooperativeMatrixPropertiesNV* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeMatrixSupportedStages = copy_src->cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceCoverageReductionModeFeaturesNV::PhysicalDeviceCoverageReductionModeFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceCoverageReductionModeFeaturesNV::PhysicalDeviceCoverageReductionModeFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV), pNext(nullptr), coverageReductionMode() {}
+
+PhysicalDeviceCoverageReductionModeFeaturesNV::PhysicalDeviceCoverageReductionModeFeaturesNV(
+    const PhysicalDeviceCoverageReductionModeFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    coverageReductionMode = copy_src.coverageReductionMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCoverageReductionModeFeaturesNV& PhysicalDeviceCoverageReductionModeFeaturesNV::operator=(
+    const PhysicalDeviceCoverageReductionModeFeaturesNV& 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;
+}
+
+PhysicalDeviceCoverageReductionModeFeaturesNV::~PhysicalDeviceCoverageReductionModeFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCoverageReductionModeFeaturesNV::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 PhysicalDeviceCoverageReductionModeFeaturesNV::initialize(const PhysicalDeviceCoverageReductionModeFeaturesNV* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    coverageReductionMode = copy_src->coverageReductionMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineCoverageReductionStateCreateInfoNV::PipelineCoverageReductionStateCreateInfoNV(
+    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);
+    }
+}
+
+PipelineCoverageReductionStateCreateInfoNV::PipelineCoverageReductionStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV), pNext(nullptr), flags(), coverageReductionMode() {}
+
+PipelineCoverageReductionStateCreateInfoNV::PipelineCoverageReductionStateCreateInfoNV(
+    const PipelineCoverageReductionStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    coverageReductionMode = copy_src.coverageReductionMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineCoverageReductionStateCreateInfoNV& PipelineCoverageReductionStateCreateInfoNV::operator=(
+    const PipelineCoverageReductionStateCreateInfoNV& 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;
+}
+
+PipelineCoverageReductionStateCreateInfoNV::~PipelineCoverageReductionStateCreateInfoNV() { FreePnextChain(pNext); }
+
+void PipelineCoverageReductionStateCreateInfoNV::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 PipelineCoverageReductionStateCreateInfoNV::initialize(const PipelineCoverageReductionStateCreateInfoNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    coverageReductionMode = copy_src->coverageReductionMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+FramebufferMixedSamplesCombinationNV::FramebufferMixedSamplesCombinationNV(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);
+    }
+}
+
+FramebufferMixedSamplesCombinationNV::FramebufferMixedSamplesCombinationNV()
+    : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV),
+      pNext(nullptr),
+      coverageReductionMode(),
+      rasterizationSamples(),
+      depthStencilSamples(),
+      colorSamples() {}
+
+FramebufferMixedSamplesCombinationNV::FramebufferMixedSamplesCombinationNV(const FramebufferMixedSamplesCombinationNV& 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);
+}
+
+FramebufferMixedSamplesCombinationNV& FramebufferMixedSamplesCombinationNV::operator=(
+    const FramebufferMixedSamplesCombinationNV& 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;
+}
+
+FramebufferMixedSamplesCombinationNV::~FramebufferMixedSamplesCombinationNV() { FreePnextChain(pNext); }
+
+void FramebufferMixedSamplesCombinationNV::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 FramebufferMixedSamplesCombinationNV::initialize(const FramebufferMixedSamplesCombinationNV* 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);
+}
+
+PhysicalDeviceDeviceGeneratedCommandsPropertiesNV::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceDeviceGeneratedCommandsPropertiesNV::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV),
+      pNext(nullptr),
+      maxGraphicsShaderGroupCount(),
+      maxIndirectSequenceCount(),
+      maxIndirectCommandsTokenCount(),
+      maxIndirectCommandsStreamCount(),
+      maxIndirectCommandsTokenOffset(),
+      maxIndirectCommandsStreamStride(),
+      minSequencesCountBufferOffsetAlignment(),
+      minSequencesIndexBufferOffsetAlignment(),
+      minIndirectCommandsBufferOffsetAlignment() {}
+
+PhysicalDeviceDeviceGeneratedCommandsPropertiesNV::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+    const PhysicalDeviceDeviceGeneratedCommandsPropertiesNV& 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);
+}
+
+PhysicalDeviceDeviceGeneratedCommandsPropertiesNV& PhysicalDeviceDeviceGeneratedCommandsPropertiesNV::operator=(
+    const PhysicalDeviceDeviceGeneratedCommandsPropertiesNV& 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;
+}
+
+PhysicalDeviceDeviceGeneratedCommandsPropertiesNV::~PhysicalDeviceDeviceGeneratedCommandsPropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDeviceGeneratedCommandsPropertiesNV::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 PhysicalDeviceDeviceGeneratedCommandsPropertiesNV::initialize(
+    const PhysicalDeviceDeviceGeneratedCommandsPropertiesNV* 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);
+}
+
+PhysicalDeviceDeviceGeneratedCommandsFeaturesNV::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceDeviceGeneratedCommandsFeaturesNV::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV), pNext(nullptr), deviceGeneratedCommands() {}
+
+PhysicalDeviceDeviceGeneratedCommandsFeaturesNV::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+    const PhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    deviceGeneratedCommands = copy_src.deviceGeneratedCommands;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDeviceGeneratedCommandsFeaturesNV& PhysicalDeviceDeviceGeneratedCommandsFeaturesNV::operator=(
+    const PhysicalDeviceDeviceGeneratedCommandsFeaturesNV& 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;
+}
+
+PhysicalDeviceDeviceGeneratedCommandsFeaturesNV::~PhysicalDeviceDeviceGeneratedCommandsFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDeviceGeneratedCommandsFeaturesNV::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 PhysicalDeviceDeviceGeneratedCommandsFeaturesNV::initialize(const PhysicalDeviceDeviceGeneratedCommandsFeaturesNV* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceGeneratedCommands = copy_src->deviceGeneratedCommands;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+GraphicsShaderGroupCreateInfoNV::GraphicsShaderGroupCreateInfoNV(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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pVertexInputState) pVertexInputState = new PipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
+    if (in_struct->pTessellationState) pTessellationState = new PipelineTessellationStateCreateInfo(in_struct->pTessellationState);
+}
+
+GraphicsShaderGroupCreateInfoNV::GraphicsShaderGroupCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV),
+      pNext(nullptr),
+      stageCount(),
+      pStages(nullptr),
+      pVertexInputState(nullptr),
+      pTessellationState(nullptr) {}
+
+GraphicsShaderGroupCreateInfoNV::GraphicsShaderGroupCreateInfoNV(const GraphicsShaderGroupCreateInfoNV& 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pVertexInputState) pVertexInputState = new PipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
+    if (copy_src.pTessellationState) pTessellationState = new PipelineTessellationStateCreateInfo(*copy_src.pTessellationState);
+}
+
+GraphicsShaderGroupCreateInfoNV& GraphicsShaderGroupCreateInfoNV::operator=(const GraphicsShaderGroupCreateInfoNV& 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pVertexInputState) pVertexInputState = new PipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
+    if (copy_src.pTessellationState) pTessellationState = new PipelineTessellationStateCreateInfo(*copy_src.pTessellationState);
+
+    return *this;
+}
+
+GraphicsShaderGroupCreateInfoNV::~GraphicsShaderGroupCreateInfoNV() {
+    if (pStages) delete[] pStages;
+    if (pVertexInputState) delete pVertexInputState;
+    if (pTessellationState) delete pTessellationState;
+    FreePnextChain(pNext);
+}
+
+void GraphicsShaderGroupCreateInfoNV::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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pVertexInputState) pVertexInputState = new PipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
+    if (in_struct->pTessellationState) pTessellationState = new PipelineTessellationStateCreateInfo(in_struct->pTessellationState);
+}
+
+void GraphicsShaderGroupCreateInfoNV::initialize(const GraphicsShaderGroupCreateInfoNV* 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 PipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src->pStages[i]);
+        }
+    }
+    if (copy_src->pVertexInputState) pVertexInputState = new PipelineVertexInputStateCreateInfo(*copy_src->pVertexInputState);
+    if (copy_src->pTessellationState) pTessellationState = new PipelineTessellationStateCreateInfo(*copy_src->pTessellationState);
+}
+
+GraphicsPipelineShaderGroupsCreateInfoNV::GraphicsPipelineShaderGroupsCreateInfoNV(
+    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 GraphicsShaderGroupCreateInfoNV[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];
+        }
+    }
+}
+
+GraphicsPipelineShaderGroupsCreateInfoNV::GraphicsPipelineShaderGroupsCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV),
+      pNext(nullptr),
+      groupCount(),
+      pGroups(nullptr),
+      pipelineCount(),
+      pPipelines(nullptr) {}
+
+GraphicsPipelineShaderGroupsCreateInfoNV::GraphicsPipelineShaderGroupsCreateInfoNV(
+    const GraphicsPipelineShaderGroupsCreateInfoNV& 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 GraphicsShaderGroupCreateInfoNV[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];
+        }
+    }
+}
+
+GraphicsPipelineShaderGroupsCreateInfoNV& GraphicsPipelineShaderGroupsCreateInfoNV::operator=(
+    const GraphicsPipelineShaderGroupsCreateInfoNV& 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 GraphicsShaderGroupCreateInfoNV[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;
+}
+
+GraphicsPipelineShaderGroupsCreateInfoNV::~GraphicsPipelineShaderGroupsCreateInfoNV() {
+    if (pGroups) delete[] pGroups;
+    if (pPipelines) delete[] pPipelines;
+    FreePnextChain(pNext);
+}
+
+void GraphicsPipelineShaderGroupsCreateInfoNV::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 GraphicsShaderGroupCreateInfoNV[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 GraphicsPipelineShaderGroupsCreateInfoNV::initialize(const GraphicsPipelineShaderGroupsCreateInfoNV* 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 GraphicsShaderGroupCreateInfoNV[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];
+        }
+    }
+}
+
+IndirectCommandsLayoutTokenNV::IndirectCommandsLayoutTokenNV(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);
+    }
+}
+
+IndirectCommandsLayoutTokenNV::IndirectCommandsLayoutTokenNV()
+    : 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) {}
+
+IndirectCommandsLayoutTokenNV::IndirectCommandsLayoutTokenNV(const IndirectCommandsLayoutTokenNV& 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);
+    }
+}
+
+IndirectCommandsLayoutTokenNV& IndirectCommandsLayoutTokenNV::operator=(const IndirectCommandsLayoutTokenNV& 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;
+}
+
+IndirectCommandsLayoutTokenNV::~IndirectCommandsLayoutTokenNV() {
+    if (pIndexTypes) delete[] pIndexTypes;
+    if (pIndexTypeValues) delete[] pIndexTypeValues;
+    FreePnextChain(pNext);
+}
+
+void IndirectCommandsLayoutTokenNV::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 IndirectCommandsLayoutTokenNV::initialize(const IndirectCommandsLayoutTokenNV* 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);
+    }
+}
+
+IndirectCommandsLayoutCreateInfoNV::IndirectCommandsLayoutCreateInfoNV(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 IndirectCommandsLayoutTokenNV[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);
+    }
+}
+
+IndirectCommandsLayoutCreateInfoNV::IndirectCommandsLayoutCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV),
+      pNext(nullptr),
+      flags(),
+      pipelineBindPoint(),
+      tokenCount(),
+      pTokens(nullptr),
+      streamCount(),
+      pStreamStrides(nullptr) {}
+
+IndirectCommandsLayoutCreateInfoNV::IndirectCommandsLayoutCreateInfoNV(const IndirectCommandsLayoutCreateInfoNV& 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 IndirectCommandsLayoutTokenNV[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);
+    }
+}
+
+IndirectCommandsLayoutCreateInfoNV& IndirectCommandsLayoutCreateInfoNV::operator=(
+    const IndirectCommandsLayoutCreateInfoNV& 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 IndirectCommandsLayoutTokenNV[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;
+}
+
+IndirectCommandsLayoutCreateInfoNV::~IndirectCommandsLayoutCreateInfoNV() {
+    if (pTokens) delete[] pTokens;
+    if (pStreamStrides) delete[] pStreamStrides;
+    FreePnextChain(pNext);
+}
+
+void IndirectCommandsLayoutCreateInfoNV::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 IndirectCommandsLayoutTokenNV[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 IndirectCommandsLayoutCreateInfoNV::initialize(const IndirectCommandsLayoutCreateInfoNV* 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 IndirectCommandsLayoutTokenNV[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);
+    }
+}
+
+GeneratedCommandsInfoNV::GeneratedCommandsInfoNV(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];
+        }
+    }
+}
+
+GeneratedCommandsInfoNV::GeneratedCommandsInfoNV()
+    : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV),
+      pNext(nullptr),
+      pipelineBindPoint(),
+      pipeline(),
+      indirectCommandsLayout(),
+      streamCount(),
+      pStreams(nullptr),
+      sequencesCount(),
+      preprocessBuffer(),
+      preprocessOffset(),
+      preprocessSize(),
+      sequencesCountBuffer(),
+      sequencesCountOffset(),
+      sequencesIndexBuffer(),
+      sequencesIndexOffset() {}
+
+GeneratedCommandsInfoNV::GeneratedCommandsInfoNV(const GeneratedCommandsInfoNV& 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];
+        }
+    }
+}
+
+GeneratedCommandsInfoNV& GeneratedCommandsInfoNV::operator=(const GeneratedCommandsInfoNV& 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;
+}
+
+GeneratedCommandsInfoNV::~GeneratedCommandsInfoNV() {
+    if (pStreams) delete[] pStreams;
+    FreePnextChain(pNext);
+}
+
+void GeneratedCommandsInfoNV::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 GeneratedCommandsInfoNV::initialize(const GeneratedCommandsInfoNV* 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];
+        }
+    }
+}
+
+GeneratedCommandsMemoryRequirementsInfoNV::GeneratedCommandsMemoryRequirementsInfoNV(
+    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);
+    }
+}
+
+GeneratedCommandsMemoryRequirementsInfoNV::GeneratedCommandsMemoryRequirementsInfoNV()
+    : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV),
+      pNext(nullptr),
+      pipelineBindPoint(),
+      pipeline(),
+      indirectCommandsLayout(),
+      maxSequencesCount() {}
+
+GeneratedCommandsMemoryRequirementsInfoNV::GeneratedCommandsMemoryRequirementsInfoNV(
+    const GeneratedCommandsMemoryRequirementsInfoNV& 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);
+}
+
+GeneratedCommandsMemoryRequirementsInfoNV& GeneratedCommandsMemoryRequirementsInfoNV::operator=(
+    const GeneratedCommandsMemoryRequirementsInfoNV& 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;
+}
+
+GeneratedCommandsMemoryRequirementsInfoNV::~GeneratedCommandsMemoryRequirementsInfoNV() { FreePnextChain(pNext); }
+
+void GeneratedCommandsMemoryRequirementsInfoNV::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 GeneratedCommandsMemoryRequirementsInfoNV::initialize(const GeneratedCommandsMemoryRequirementsInfoNV* 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);
+}
+
+PhysicalDeviceInheritedViewportScissorFeaturesNV::PhysicalDeviceInheritedViewportScissorFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceInheritedViewportScissorFeaturesNV::PhysicalDeviceInheritedViewportScissorFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV),
+      pNext(nullptr),
+      inheritedViewportScissor2D() {}
+
+PhysicalDeviceInheritedViewportScissorFeaturesNV::PhysicalDeviceInheritedViewportScissorFeaturesNV(
+    const PhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    inheritedViewportScissor2D = copy_src.inheritedViewportScissor2D;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceInheritedViewportScissorFeaturesNV& PhysicalDeviceInheritedViewportScissorFeaturesNV::operator=(
+    const PhysicalDeviceInheritedViewportScissorFeaturesNV& 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;
+}
+
+PhysicalDeviceInheritedViewportScissorFeaturesNV::~PhysicalDeviceInheritedViewportScissorFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceInheritedViewportScissorFeaturesNV::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 PhysicalDeviceInheritedViewportScissorFeaturesNV::initialize(const PhysicalDeviceInheritedViewportScissorFeaturesNV* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    inheritedViewportScissor2D = copy_src->inheritedViewportScissor2D;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CommandBufferInheritanceViewportScissorInfoNV::CommandBufferInheritanceViewportScissorInfoNV(
+    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);
+    }
+}
+
+CommandBufferInheritanceViewportScissorInfoNV::CommandBufferInheritanceViewportScissorInfoNV()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV),
+      pNext(nullptr),
+      viewportScissor2D(),
+      viewportDepthCount(),
+      pViewportDepths(nullptr) {}
+
+CommandBufferInheritanceViewportScissorInfoNV::CommandBufferInheritanceViewportScissorInfoNV(
+    const CommandBufferInheritanceViewportScissorInfoNV& 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);
+    }
+}
+
+CommandBufferInheritanceViewportScissorInfoNV& CommandBufferInheritanceViewportScissorInfoNV::operator=(
+    const CommandBufferInheritanceViewportScissorInfoNV& 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;
+}
+
+CommandBufferInheritanceViewportScissorInfoNV::~CommandBufferInheritanceViewportScissorInfoNV() {
+    if (pViewportDepths) delete pViewportDepths;
+    FreePnextChain(pNext);
+}
+
+void CommandBufferInheritanceViewportScissorInfoNV::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 CommandBufferInheritanceViewportScissorInfoNV::initialize(const CommandBufferInheritanceViewportScissorInfoNV* 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);
+    }
+}
+
+RenderPassTransformBeginInfoQCOM::RenderPassTransformBeginInfoQCOM(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);
+    }
+}
+
+RenderPassTransformBeginInfoQCOM::RenderPassTransformBeginInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM), pNext(nullptr), transform() {}
+
+RenderPassTransformBeginInfoQCOM::RenderPassTransformBeginInfoQCOM(const RenderPassTransformBeginInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    transform = copy_src.transform;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+RenderPassTransformBeginInfoQCOM& RenderPassTransformBeginInfoQCOM::operator=(const RenderPassTransformBeginInfoQCOM& 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;
+}
+
+RenderPassTransformBeginInfoQCOM::~RenderPassTransformBeginInfoQCOM() { FreePnextChain(pNext); }
+
+void RenderPassTransformBeginInfoQCOM::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 RenderPassTransformBeginInfoQCOM::initialize(const RenderPassTransformBeginInfoQCOM* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    transform = copy_src->transform;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CommandBufferInheritanceRenderPassTransformInfoQCOM::CommandBufferInheritanceRenderPassTransformInfoQCOM(
+    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);
+    }
+}
+
+CommandBufferInheritanceRenderPassTransformInfoQCOM::CommandBufferInheritanceRenderPassTransformInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM),
+      pNext(nullptr),
+      transform(),
+      renderArea() {}
+
+CommandBufferInheritanceRenderPassTransformInfoQCOM::CommandBufferInheritanceRenderPassTransformInfoQCOM(
+    const CommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    transform = copy_src.transform;
+    renderArea = copy_src.renderArea;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CommandBufferInheritanceRenderPassTransformInfoQCOM& CommandBufferInheritanceRenderPassTransformInfoQCOM::operator=(
+    const CommandBufferInheritanceRenderPassTransformInfoQCOM& 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;
+}
+
+CommandBufferInheritanceRenderPassTransformInfoQCOM::~CommandBufferInheritanceRenderPassTransformInfoQCOM() {
+    FreePnextChain(pNext);
+}
+
+void CommandBufferInheritanceRenderPassTransformInfoQCOM::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 CommandBufferInheritanceRenderPassTransformInfoQCOM::initialize(
+    const CommandBufferInheritanceRenderPassTransformInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    transform = copy_src->transform;
+    renderArea = copy_src->renderArea;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDevicePresentBarrierFeaturesNV::PhysicalDevicePresentBarrierFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDevicePresentBarrierFeaturesNV::PhysicalDevicePresentBarrierFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV), pNext(nullptr), presentBarrier() {}
+
+PhysicalDevicePresentBarrierFeaturesNV::PhysicalDevicePresentBarrierFeaturesNV(
+    const PhysicalDevicePresentBarrierFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    presentBarrier = copy_src.presentBarrier;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePresentBarrierFeaturesNV& PhysicalDevicePresentBarrierFeaturesNV::operator=(
+    const PhysicalDevicePresentBarrierFeaturesNV& 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;
+}
+
+PhysicalDevicePresentBarrierFeaturesNV::~PhysicalDevicePresentBarrierFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDevicePresentBarrierFeaturesNV::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 PhysicalDevicePresentBarrierFeaturesNV::initialize(const PhysicalDevicePresentBarrierFeaturesNV* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentBarrier = copy_src->presentBarrier;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SurfaceCapabilitiesPresentBarrierNV::SurfaceCapabilitiesPresentBarrierNV(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);
+    }
+}
+
+SurfaceCapabilitiesPresentBarrierNV::SurfaceCapabilitiesPresentBarrierNV()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV), pNext(nullptr), presentBarrierSupported() {}
+
+SurfaceCapabilitiesPresentBarrierNV::SurfaceCapabilitiesPresentBarrierNV(const SurfaceCapabilitiesPresentBarrierNV& copy_src) {
+    sType = copy_src.sType;
+    presentBarrierSupported = copy_src.presentBarrierSupported;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SurfaceCapabilitiesPresentBarrierNV& SurfaceCapabilitiesPresentBarrierNV::operator=(
+    const SurfaceCapabilitiesPresentBarrierNV& 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;
+}
+
+SurfaceCapabilitiesPresentBarrierNV::~SurfaceCapabilitiesPresentBarrierNV() { FreePnextChain(pNext); }
+
+void SurfaceCapabilitiesPresentBarrierNV::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 SurfaceCapabilitiesPresentBarrierNV::initialize(const SurfaceCapabilitiesPresentBarrierNV* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentBarrierSupported = copy_src->presentBarrierSupported;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SwapchainPresentBarrierCreateInfoNV::SwapchainPresentBarrierCreateInfoNV(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);
+    }
+}
+
+SwapchainPresentBarrierCreateInfoNV::SwapchainPresentBarrierCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV), pNext(nullptr), presentBarrierEnable() {}
+
+SwapchainPresentBarrierCreateInfoNV::SwapchainPresentBarrierCreateInfoNV(const SwapchainPresentBarrierCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    presentBarrierEnable = copy_src.presentBarrierEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SwapchainPresentBarrierCreateInfoNV& SwapchainPresentBarrierCreateInfoNV::operator=(
+    const SwapchainPresentBarrierCreateInfoNV& 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;
+}
+
+SwapchainPresentBarrierCreateInfoNV::~SwapchainPresentBarrierCreateInfoNV() { FreePnextChain(pNext); }
+
+void SwapchainPresentBarrierCreateInfoNV::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 SwapchainPresentBarrierCreateInfoNV::initialize(const SwapchainPresentBarrierCreateInfoNV* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentBarrierEnable = copy_src->presentBarrierEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDiagnosticsConfigFeaturesNV::PhysicalDeviceDiagnosticsConfigFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceDiagnosticsConfigFeaturesNV::PhysicalDeviceDiagnosticsConfigFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV), pNext(nullptr), diagnosticsConfig() {}
+
+PhysicalDeviceDiagnosticsConfigFeaturesNV::PhysicalDeviceDiagnosticsConfigFeaturesNV(
+    const PhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    diagnosticsConfig = copy_src.diagnosticsConfig;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDiagnosticsConfigFeaturesNV& PhysicalDeviceDiagnosticsConfigFeaturesNV::operator=(
+    const PhysicalDeviceDiagnosticsConfigFeaturesNV& 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;
+}
+
+PhysicalDeviceDiagnosticsConfigFeaturesNV::~PhysicalDeviceDiagnosticsConfigFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDiagnosticsConfigFeaturesNV::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 PhysicalDeviceDiagnosticsConfigFeaturesNV::initialize(const PhysicalDeviceDiagnosticsConfigFeaturesNV* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    diagnosticsConfig = copy_src->diagnosticsConfig;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DeviceDiagnosticsConfigCreateInfoNV::DeviceDiagnosticsConfigCreateInfoNV(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);
+    }
+}
+
+DeviceDiagnosticsConfigCreateInfoNV::DeviceDiagnosticsConfigCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV), pNext(nullptr), flags() {}
+
+DeviceDiagnosticsConfigCreateInfoNV::DeviceDiagnosticsConfigCreateInfoNV(const DeviceDiagnosticsConfigCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceDiagnosticsConfigCreateInfoNV& DeviceDiagnosticsConfigCreateInfoNV::operator=(
+    const DeviceDiagnosticsConfigCreateInfoNV& 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;
+}
+
+DeviceDiagnosticsConfigCreateInfoNV::~DeviceDiagnosticsConfigCreateInfoNV() { FreePnextChain(pNext); }
+
+void DeviceDiagnosticsConfigCreateInfoNV::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 DeviceDiagnosticsConfigCreateInfoNV::initialize(const DeviceDiagnosticsConfigCreateInfoNV* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CudaModuleCreateInfoNV::CudaModuleCreateInfoNV(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;
+    }
+}
+
+CudaModuleCreateInfoNV::CudaModuleCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV), pNext(nullptr), dataSize(), pData(nullptr) {}
+
+CudaModuleCreateInfoNV::CudaModuleCreateInfoNV(const CudaModuleCreateInfoNV& 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;
+    }
+}
+
+CudaModuleCreateInfoNV& CudaModuleCreateInfoNV::operator=(const CudaModuleCreateInfoNV& 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;
+}
+
+CudaModuleCreateInfoNV::~CudaModuleCreateInfoNV() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+}
+
+void CudaModuleCreateInfoNV::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 CudaModuleCreateInfoNV::initialize(const CudaModuleCreateInfoNV* 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;
+    }
+}
+
+CudaFunctionCreateInfoNV::CudaFunctionCreateInfoNV(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);
+}
+
+CudaFunctionCreateInfoNV::CudaFunctionCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV), pNext(nullptr), module(), pName(nullptr) {}
+
+CudaFunctionCreateInfoNV::CudaFunctionCreateInfoNV(const CudaFunctionCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    module = copy_src.module;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+}
+
+CudaFunctionCreateInfoNV& CudaFunctionCreateInfoNV::operator=(const CudaFunctionCreateInfoNV& 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;
+}
+
+CudaFunctionCreateInfoNV::~CudaFunctionCreateInfoNV() {
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+}
+
+void CudaFunctionCreateInfoNV::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 CudaFunctionCreateInfoNV::initialize(const CudaFunctionCreateInfoNV* 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);
+}
+
+CudaLaunchInfoNV::CudaLaunchInfoNV(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);
+    }
+}
+
+CudaLaunchInfoNV::CudaLaunchInfoNV()
+    : sType(VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV),
+      pNext(nullptr),
+      function(),
+      gridDimX(),
+      gridDimY(),
+      gridDimZ(),
+      blockDimX(),
+      blockDimY(),
+      blockDimZ(),
+      sharedMemBytes(),
+      paramCount(),
+      pParams(nullptr),
+      extraCount(),
+      pExtras(nullptr) {}
+
+CudaLaunchInfoNV::CudaLaunchInfoNV(const CudaLaunchInfoNV& 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);
+}
+
+CudaLaunchInfoNV& CudaLaunchInfoNV::operator=(const CudaLaunchInfoNV& 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;
+}
+
+CudaLaunchInfoNV::~CudaLaunchInfoNV() { FreePnextChain(pNext); }
+
+void CudaLaunchInfoNV::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 CudaLaunchInfoNV::initialize(const CudaLaunchInfoNV* 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);
+}
+
+PhysicalDeviceCudaKernelLaunchFeaturesNV::PhysicalDeviceCudaKernelLaunchFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceCudaKernelLaunchFeaturesNV::PhysicalDeviceCudaKernelLaunchFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV), pNext(nullptr), cudaKernelLaunchFeatures() {}
+
+PhysicalDeviceCudaKernelLaunchFeaturesNV::PhysicalDeviceCudaKernelLaunchFeaturesNV(
+    const PhysicalDeviceCudaKernelLaunchFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    cudaKernelLaunchFeatures = copy_src.cudaKernelLaunchFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCudaKernelLaunchFeaturesNV& PhysicalDeviceCudaKernelLaunchFeaturesNV::operator=(
+    const PhysicalDeviceCudaKernelLaunchFeaturesNV& 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;
+}
+
+PhysicalDeviceCudaKernelLaunchFeaturesNV::~PhysicalDeviceCudaKernelLaunchFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCudaKernelLaunchFeaturesNV::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 PhysicalDeviceCudaKernelLaunchFeaturesNV::initialize(const PhysicalDeviceCudaKernelLaunchFeaturesNV* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cudaKernelLaunchFeatures = copy_src->cudaKernelLaunchFeatures;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceCudaKernelLaunchPropertiesNV::PhysicalDeviceCudaKernelLaunchPropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceCudaKernelLaunchPropertiesNV::PhysicalDeviceCudaKernelLaunchPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV),
+      pNext(nullptr),
+      computeCapabilityMinor(),
+      computeCapabilityMajor() {}
+
+PhysicalDeviceCudaKernelLaunchPropertiesNV::PhysicalDeviceCudaKernelLaunchPropertiesNV(
+    const PhysicalDeviceCudaKernelLaunchPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    computeCapabilityMinor = copy_src.computeCapabilityMinor;
+    computeCapabilityMajor = copy_src.computeCapabilityMajor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCudaKernelLaunchPropertiesNV& PhysicalDeviceCudaKernelLaunchPropertiesNV::operator=(
+    const PhysicalDeviceCudaKernelLaunchPropertiesNV& 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;
+}
+
+PhysicalDeviceCudaKernelLaunchPropertiesNV::~PhysicalDeviceCudaKernelLaunchPropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCudaKernelLaunchPropertiesNV::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 PhysicalDeviceCudaKernelLaunchPropertiesNV::initialize(const PhysicalDeviceCudaKernelLaunchPropertiesNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    computeCapabilityMinor = copy_src->computeCapabilityMinor;
+    computeCapabilityMajor = copy_src->computeCapabilityMajor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+QueryLowLatencySupportNV::QueryLowLatencySupportNV(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);
+    }
+}
+
+QueryLowLatencySupportNV::QueryLowLatencySupportNV()
+    : sType(VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV), pNext(nullptr), pQueriedLowLatencyData(nullptr) {}
+
+QueryLowLatencySupportNV::QueryLowLatencySupportNV(const QueryLowLatencySupportNV& copy_src) {
+    sType = copy_src.sType;
+    pQueriedLowLatencyData = copy_src.pQueriedLowLatencyData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+QueryLowLatencySupportNV& QueryLowLatencySupportNV::operator=(const QueryLowLatencySupportNV& 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;
+}
+
+QueryLowLatencySupportNV::~QueryLowLatencySupportNV() { FreePnextChain(pNext); }
+
+void QueryLowLatencySupportNV::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 QueryLowLatencySupportNV::initialize(const QueryLowLatencySupportNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pQueriedLowLatencyData = copy_src->pQueriedLowLatencyData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    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);
+    }
+}
+
+PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD),
+      pNext(nullptr),
+      shaderEarlyAndLateFragmentTests() {}
+
+PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    const PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& copy_src) {
+    sType = copy_src.sType;
+    shaderEarlyAndLateFragmentTests = copy_src.shaderEarlyAndLateFragmentTests;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::operator=(
+    const PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& 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;
+}
+
+PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::~PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::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 PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::initialize(
+    const PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderEarlyAndLateFragmentTests = copy_src->shaderEarlyAndLateFragmentTests;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceFragmentShadingRateEnumsFeaturesNV::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentShadingRateEnumsFeaturesNV::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV),
+      pNext(nullptr),
+      fragmentShadingRateEnums(),
+      supersampleFragmentShadingRates(),
+      noInvocationFragmentShadingRates() {}
+
+PhysicalDeviceFragmentShadingRateEnumsFeaturesNV::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+    const PhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    fragmentShadingRateEnums = copy_src.fragmentShadingRateEnums;
+    supersampleFragmentShadingRates = copy_src.supersampleFragmentShadingRates;
+    noInvocationFragmentShadingRates = copy_src.noInvocationFragmentShadingRates;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentShadingRateEnumsFeaturesNV& PhysicalDeviceFragmentShadingRateEnumsFeaturesNV::operator=(
+    const PhysicalDeviceFragmentShadingRateEnumsFeaturesNV& 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;
+}
+
+PhysicalDeviceFragmentShadingRateEnumsFeaturesNV::~PhysicalDeviceFragmentShadingRateEnumsFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentShadingRateEnumsFeaturesNV::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 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV::initialize(const PhysicalDeviceFragmentShadingRateEnumsFeaturesNV* 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);
+}
+
+PhysicalDeviceFragmentShadingRateEnumsPropertiesNV::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentShadingRateEnumsPropertiesNV::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV),
+      pNext(nullptr),
+      maxFragmentShadingRateInvocationCount() {}
+
+PhysicalDeviceFragmentShadingRateEnumsPropertiesNV::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+    const PhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    maxFragmentShadingRateInvocationCount = copy_src.maxFragmentShadingRateInvocationCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentShadingRateEnumsPropertiesNV& PhysicalDeviceFragmentShadingRateEnumsPropertiesNV::operator=(
+    const PhysicalDeviceFragmentShadingRateEnumsPropertiesNV& 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;
+}
+
+PhysicalDeviceFragmentShadingRateEnumsPropertiesNV::~PhysicalDeviceFragmentShadingRateEnumsPropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentShadingRateEnumsPropertiesNV::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 PhysicalDeviceFragmentShadingRateEnumsPropertiesNV::initialize(
+    const PhysicalDeviceFragmentShadingRateEnumsPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxFragmentShadingRateInvocationCount = copy_src->maxFragmentShadingRateInvocationCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PipelineFragmentShadingRateEnumStateCreateInfoNV::PipelineFragmentShadingRateEnumStateCreateInfoNV(
+    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];
+    }
+}
+
+PipelineFragmentShadingRateEnumStateCreateInfoNV::PipelineFragmentShadingRateEnumStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      shadingRateType(),
+      shadingRate() {}
+
+PipelineFragmentShadingRateEnumStateCreateInfoNV::PipelineFragmentShadingRateEnumStateCreateInfoNV(
+    const PipelineFragmentShadingRateEnumStateCreateInfoNV& 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];
+    }
+}
+
+PipelineFragmentShadingRateEnumStateCreateInfoNV& PipelineFragmentShadingRateEnumStateCreateInfoNV::operator=(
+    const PipelineFragmentShadingRateEnumStateCreateInfoNV& 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;
+}
+
+PipelineFragmentShadingRateEnumStateCreateInfoNV::~PipelineFragmentShadingRateEnumStateCreateInfoNV() { FreePnextChain(pNext); }
+
+void PipelineFragmentShadingRateEnumStateCreateInfoNV::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 PipelineFragmentShadingRateEnumStateCreateInfoNV::initialize(const PipelineFragmentShadingRateEnumStateCreateInfoNV* 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];
+    }
+}
+
+AccelerationStructureGeometryMotionTrianglesDataNV::AccelerationStructureGeometryMotionTrianglesDataNV(
+    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);
+    }
+}
+
+AccelerationStructureGeometryMotionTrianglesDataNV::AccelerationStructureGeometryMotionTrianglesDataNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV), pNext(nullptr) {}
+
+AccelerationStructureGeometryMotionTrianglesDataNV::AccelerationStructureGeometryMotionTrianglesDataNV(
+    const AccelerationStructureGeometryMotionTrianglesDataNV& copy_src) {
+    sType = copy_src.sType;
+    vertexData.initialize(&copy_src.vertexData);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AccelerationStructureGeometryMotionTrianglesDataNV& AccelerationStructureGeometryMotionTrianglesDataNV::operator=(
+    const AccelerationStructureGeometryMotionTrianglesDataNV& 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;
+}
+
+AccelerationStructureGeometryMotionTrianglesDataNV::~AccelerationStructureGeometryMotionTrianglesDataNV() { FreePnextChain(pNext); }
+
+void AccelerationStructureGeometryMotionTrianglesDataNV::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 AccelerationStructureGeometryMotionTrianglesDataNV::initialize(
+    const AccelerationStructureGeometryMotionTrianglesDataNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexData.initialize(&copy_src->vertexData);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+AccelerationStructureMotionInfoNV::AccelerationStructureMotionInfoNV(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);
+    }
+}
+
+AccelerationStructureMotionInfoNV::AccelerationStructureMotionInfoNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV), pNext(nullptr), maxInstances(), flags() {}
+
+AccelerationStructureMotionInfoNV::AccelerationStructureMotionInfoNV(const AccelerationStructureMotionInfoNV& copy_src) {
+    sType = copy_src.sType;
+    maxInstances = copy_src.maxInstances;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AccelerationStructureMotionInfoNV& AccelerationStructureMotionInfoNV::operator=(const AccelerationStructureMotionInfoNV& 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;
+}
+
+AccelerationStructureMotionInfoNV::~AccelerationStructureMotionInfoNV() { FreePnextChain(pNext); }
+
+void AccelerationStructureMotionInfoNV::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 AccelerationStructureMotionInfoNV::initialize(const AccelerationStructureMotionInfoNV* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxInstances = copy_src->maxInstances;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceRayTracingMotionBlurFeaturesNV::PhysicalDeviceRayTracingMotionBlurFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceRayTracingMotionBlurFeaturesNV::PhysicalDeviceRayTracingMotionBlurFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV),
+      pNext(nullptr),
+      rayTracingMotionBlur(),
+      rayTracingMotionBlurPipelineTraceRaysIndirect() {}
+
+PhysicalDeviceRayTracingMotionBlurFeaturesNV::PhysicalDeviceRayTracingMotionBlurFeaturesNV(
+    const PhysicalDeviceRayTracingMotionBlurFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    rayTracingMotionBlur = copy_src.rayTracingMotionBlur;
+    rayTracingMotionBlurPipelineTraceRaysIndirect = copy_src.rayTracingMotionBlurPipelineTraceRaysIndirect;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRayTracingMotionBlurFeaturesNV& PhysicalDeviceRayTracingMotionBlurFeaturesNV::operator=(
+    const PhysicalDeviceRayTracingMotionBlurFeaturesNV& 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;
+}
+
+PhysicalDeviceRayTracingMotionBlurFeaturesNV::~PhysicalDeviceRayTracingMotionBlurFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRayTracingMotionBlurFeaturesNV::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 PhysicalDeviceRayTracingMotionBlurFeaturesNV::initialize(const PhysicalDeviceRayTracingMotionBlurFeaturesNV* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingMotionBlur = copy_src->rayTracingMotionBlur;
+    rayTracingMotionBlurPipelineTraceRaysIndirect = copy_src->rayTracingMotionBlurPipelineTraceRaysIndirect;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+CopyCommandTransformInfoQCOM::CopyCommandTransformInfoQCOM(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);
+    }
+}
+
+CopyCommandTransformInfoQCOM::CopyCommandTransformInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM), pNext(nullptr), transform() {}
+
+CopyCommandTransformInfoQCOM::CopyCommandTransformInfoQCOM(const CopyCommandTransformInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    transform = copy_src.transform;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+CopyCommandTransformInfoQCOM& CopyCommandTransformInfoQCOM::operator=(const CopyCommandTransformInfoQCOM& 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;
+}
+
+CopyCommandTransformInfoQCOM::~CopyCommandTransformInfoQCOM() { FreePnextChain(pNext); }
+
+void CopyCommandTransformInfoQCOM::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 CopyCommandTransformInfoQCOM::initialize(const CopyCommandTransformInfoQCOM* 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
+
+ImportMemoryZirconHandleInfoFUCHSIA::ImportMemoryZirconHandleInfoFUCHSIA(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);
+    }
+}
+
+ImportMemoryZirconHandleInfoFUCHSIA::ImportMemoryZirconHandleInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA), pNext(nullptr), handleType(), handle() {}
+
+ImportMemoryZirconHandleInfoFUCHSIA::ImportMemoryZirconHandleInfoFUCHSIA(const ImportMemoryZirconHandleInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImportMemoryZirconHandleInfoFUCHSIA& ImportMemoryZirconHandleInfoFUCHSIA::operator=(
+    const ImportMemoryZirconHandleInfoFUCHSIA& 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;
+}
+
+ImportMemoryZirconHandleInfoFUCHSIA::~ImportMemoryZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void ImportMemoryZirconHandleInfoFUCHSIA::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 ImportMemoryZirconHandleInfoFUCHSIA::initialize(const ImportMemoryZirconHandleInfoFUCHSIA* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    handle = copy_src->handle;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryZirconHandlePropertiesFUCHSIA::MemoryZirconHandlePropertiesFUCHSIA(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);
+    }
+}
+
+MemoryZirconHandlePropertiesFUCHSIA::MemoryZirconHandlePropertiesFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA), pNext(nullptr), memoryTypeBits() {}
+
+MemoryZirconHandlePropertiesFUCHSIA::MemoryZirconHandlePropertiesFUCHSIA(const MemoryZirconHandlePropertiesFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryZirconHandlePropertiesFUCHSIA& MemoryZirconHandlePropertiesFUCHSIA::operator=(
+    const MemoryZirconHandlePropertiesFUCHSIA& 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;
+}
+
+MemoryZirconHandlePropertiesFUCHSIA::~MemoryZirconHandlePropertiesFUCHSIA() { FreePnextChain(pNext); }
+
+void MemoryZirconHandlePropertiesFUCHSIA::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 MemoryZirconHandlePropertiesFUCHSIA::initialize(const MemoryZirconHandlePropertiesFUCHSIA* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryGetZirconHandleInfoFUCHSIA::MemoryGetZirconHandleInfoFUCHSIA(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);
+    }
+}
+
+MemoryGetZirconHandleInfoFUCHSIA::MemoryGetZirconHandleInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA), pNext(nullptr), memory(), handleType() {}
+
+MemoryGetZirconHandleInfoFUCHSIA::MemoryGetZirconHandleInfoFUCHSIA(const MemoryGetZirconHandleInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryGetZirconHandleInfoFUCHSIA& MemoryGetZirconHandleInfoFUCHSIA::operator=(const MemoryGetZirconHandleInfoFUCHSIA& 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;
+}
+
+MemoryGetZirconHandleInfoFUCHSIA::~MemoryGetZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void MemoryGetZirconHandleInfoFUCHSIA::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 MemoryGetZirconHandleInfoFUCHSIA::initialize(const MemoryGetZirconHandleInfoFUCHSIA* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImportSemaphoreZirconHandleInfoFUCHSIA::ImportSemaphoreZirconHandleInfoFUCHSIA(
+    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);
+    }
+}
+
+ImportSemaphoreZirconHandleInfoFUCHSIA::ImportSemaphoreZirconHandleInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA),
+      pNext(nullptr),
+      semaphore(),
+      flags(),
+      handleType(),
+      zirconHandle() {}
+
+ImportSemaphoreZirconHandleInfoFUCHSIA::ImportSemaphoreZirconHandleInfoFUCHSIA(
+    const ImportSemaphoreZirconHandleInfoFUCHSIA& 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);
+}
+
+ImportSemaphoreZirconHandleInfoFUCHSIA& ImportSemaphoreZirconHandleInfoFUCHSIA::operator=(
+    const ImportSemaphoreZirconHandleInfoFUCHSIA& 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;
+}
+
+ImportSemaphoreZirconHandleInfoFUCHSIA::~ImportSemaphoreZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void ImportSemaphoreZirconHandleInfoFUCHSIA::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 ImportSemaphoreZirconHandleInfoFUCHSIA::initialize(const ImportSemaphoreZirconHandleInfoFUCHSIA* 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);
+}
+
+SemaphoreGetZirconHandleInfoFUCHSIA::SemaphoreGetZirconHandleInfoFUCHSIA(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);
+    }
+}
+
+SemaphoreGetZirconHandleInfoFUCHSIA::SemaphoreGetZirconHandleInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA), pNext(nullptr), semaphore(), handleType() {}
+
+SemaphoreGetZirconHandleInfoFUCHSIA::SemaphoreGetZirconHandleInfoFUCHSIA(const SemaphoreGetZirconHandleInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SemaphoreGetZirconHandleInfoFUCHSIA& SemaphoreGetZirconHandleInfoFUCHSIA::operator=(
+    const SemaphoreGetZirconHandleInfoFUCHSIA& 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;
+}
+
+SemaphoreGetZirconHandleInfoFUCHSIA::~SemaphoreGetZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void SemaphoreGetZirconHandleInfoFUCHSIA::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 SemaphoreGetZirconHandleInfoFUCHSIA::initialize(const SemaphoreGetZirconHandleInfoFUCHSIA* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BufferCollectionCreateInfoFUCHSIA::BufferCollectionCreateInfoFUCHSIA(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);
+    }
+}
+
+BufferCollectionCreateInfoFUCHSIA::BufferCollectionCreateInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA), pNext(nullptr), collectionToken() {}
+
+BufferCollectionCreateInfoFUCHSIA::BufferCollectionCreateInfoFUCHSIA(const BufferCollectionCreateInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    collectionToken = copy_src.collectionToken;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BufferCollectionCreateInfoFUCHSIA& BufferCollectionCreateInfoFUCHSIA::operator=(const BufferCollectionCreateInfoFUCHSIA& 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;
+}
+
+BufferCollectionCreateInfoFUCHSIA::~BufferCollectionCreateInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void BufferCollectionCreateInfoFUCHSIA::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 BufferCollectionCreateInfoFUCHSIA::initialize(const BufferCollectionCreateInfoFUCHSIA* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    collectionToken = copy_src->collectionToken;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImportMemoryBufferCollectionFUCHSIA::ImportMemoryBufferCollectionFUCHSIA(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);
+    }
+}
+
+ImportMemoryBufferCollectionFUCHSIA::ImportMemoryBufferCollectionFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA), pNext(nullptr), collection(), index() {}
+
+ImportMemoryBufferCollectionFUCHSIA::ImportMemoryBufferCollectionFUCHSIA(const ImportMemoryBufferCollectionFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    collection = copy_src.collection;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImportMemoryBufferCollectionFUCHSIA& ImportMemoryBufferCollectionFUCHSIA::operator=(
+    const ImportMemoryBufferCollectionFUCHSIA& 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;
+}
+
+ImportMemoryBufferCollectionFUCHSIA::~ImportMemoryBufferCollectionFUCHSIA() { FreePnextChain(pNext); }
+
+void ImportMemoryBufferCollectionFUCHSIA::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 ImportMemoryBufferCollectionFUCHSIA::initialize(const ImportMemoryBufferCollectionFUCHSIA* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    collection = copy_src->collection;
+    index = copy_src->index;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BufferCollectionImageCreateInfoFUCHSIA::BufferCollectionImageCreateInfoFUCHSIA(
+    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);
+    }
+}
+
+BufferCollectionImageCreateInfoFUCHSIA::BufferCollectionImageCreateInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA), pNext(nullptr), collection(), index() {}
+
+BufferCollectionImageCreateInfoFUCHSIA::BufferCollectionImageCreateInfoFUCHSIA(
+    const BufferCollectionImageCreateInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    collection = copy_src.collection;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BufferCollectionImageCreateInfoFUCHSIA& BufferCollectionImageCreateInfoFUCHSIA::operator=(
+    const BufferCollectionImageCreateInfoFUCHSIA& 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;
+}
+
+BufferCollectionImageCreateInfoFUCHSIA::~BufferCollectionImageCreateInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void BufferCollectionImageCreateInfoFUCHSIA::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 BufferCollectionImageCreateInfoFUCHSIA::initialize(const BufferCollectionImageCreateInfoFUCHSIA* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    collection = copy_src->collection;
+    index = copy_src->index;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BufferCollectionConstraintsInfoFUCHSIA::BufferCollectionConstraintsInfoFUCHSIA(
+    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);
+    }
+}
+
+BufferCollectionConstraintsInfoFUCHSIA::BufferCollectionConstraintsInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA),
+      pNext(nullptr),
+      minBufferCount(),
+      maxBufferCount(),
+      minBufferCountForCamping(),
+      minBufferCountForDedicatedSlack(),
+      minBufferCountForSharedSlack() {}
+
+BufferCollectionConstraintsInfoFUCHSIA::BufferCollectionConstraintsInfoFUCHSIA(
+    const BufferCollectionConstraintsInfoFUCHSIA& 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);
+}
+
+BufferCollectionConstraintsInfoFUCHSIA& BufferCollectionConstraintsInfoFUCHSIA::operator=(
+    const BufferCollectionConstraintsInfoFUCHSIA& 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;
+}
+
+BufferCollectionConstraintsInfoFUCHSIA::~BufferCollectionConstraintsInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void BufferCollectionConstraintsInfoFUCHSIA::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 BufferCollectionConstraintsInfoFUCHSIA::initialize(const BufferCollectionConstraintsInfoFUCHSIA* 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);
+}
+
+BufferConstraintsInfoFUCHSIA::BufferConstraintsInfoFUCHSIA(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);
+    }
+}
+
+BufferConstraintsInfoFUCHSIA::BufferConstraintsInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA), pNext(nullptr), requiredFormatFeatures() {}
+
+BufferConstraintsInfoFUCHSIA::BufferConstraintsInfoFUCHSIA(const BufferConstraintsInfoFUCHSIA& 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);
+}
+
+BufferConstraintsInfoFUCHSIA& BufferConstraintsInfoFUCHSIA::operator=(const BufferConstraintsInfoFUCHSIA& 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;
+}
+
+BufferConstraintsInfoFUCHSIA::~BufferConstraintsInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void BufferConstraintsInfoFUCHSIA::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 BufferConstraintsInfoFUCHSIA::initialize(const BufferConstraintsInfoFUCHSIA* 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);
+}
+
+BufferCollectionBufferCreateInfoFUCHSIA::BufferCollectionBufferCreateInfoFUCHSIA(
+    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);
+    }
+}
+
+BufferCollectionBufferCreateInfoFUCHSIA::BufferCollectionBufferCreateInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA), pNext(nullptr), collection(), index() {}
+
+BufferCollectionBufferCreateInfoFUCHSIA::BufferCollectionBufferCreateInfoFUCHSIA(
+    const BufferCollectionBufferCreateInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    collection = copy_src.collection;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BufferCollectionBufferCreateInfoFUCHSIA& BufferCollectionBufferCreateInfoFUCHSIA::operator=(
+    const BufferCollectionBufferCreateInfoFUCHSIA& 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;
+}
+
+BufferCollectionBufferCreateInfoFUCHSIA::~BufferCollectionBufferCreateInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void BufferCollectionBufferCreateInfoFUCHSIA::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 BufferCollectionBufferCreateInfoFUCHSIA::initialize(const BufferCollectionBufferCreateInfoFUCHSIA* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    collection = copy_src->collection;
+    index = copy_src->index;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SysmemColorSpaceFUCHSIA::SysmemColorSpaceFUCHSIA(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);
+    }
+}
+
+SysmemColorSpaceFUCHSIA::SysmemColorSpaceFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA), pNext(nullptr), colorSpace() {}
+
+SysmemColorSpaceFUCHSIA::SysmemColorSpaceFUCHSIA(const SysmemColorSpaceFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    colorSpace = copy_src.colorSpace;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SysmemColorSpaceFUCHSIA& SysmemColorSpaceFUCHSIA::operator=(const SysmemColorSpaceFUCHSIA& 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;
+}
+
+SysmemColorSpaceFUCHSIA::~SysmemColorSpaceFUCHSIA() { FreePnextChain(pNext); }
+
+void SysmemColorSpaceFUCHSIA::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 SysmemColorSpaceFUCHSIA::initialize(const SysmemColorSpaceFUCHSIA* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    colorSpace = copy_src->colorSpace;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BufferCollectionPropertiesFUCHSIA::BufferCollectionPropertiesFUCHSIA(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);
+    }
+}
+
+BufferCollectionPropertiesFUCHSIA::BufferCollectionPropertiesFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA),
+      pNext(nullptr),
+      memoryTypeBits(),
+      bufferCount(),
+      createInfoIndex(),
+      sysmemPixelFormat(),
+      formatFeatures(),
+      samplerYcbcrConversionComponents(),
+      suggestedYcbcrModel(),
+      suggestedYcbcrRange(),
+      suggestedXChromaOffset(),
+      suggestedYChromaOffset() {}
+
+BufferCollectionPropertiesFUCHSIA::BufferCollectionPropertiesFUCHSIA(const BufferCollectionPropertiesFUCHSIA& 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);
+}
+
+BufferCollectionPropertiesFUCHSIA& BufferCollectionPropertiesFUCHSIA::operator=(const BufferCollectionPropertiesFUCHSIA& 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;
+}
+
+BufferCollectionPropertiesFUCHSIA::~BufferCollectionPropertiesFUCHSIA() { FreePnextChain(pNext); }
+
+void BufferCollectionPropertiesFUCHSIA::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 BufferCollectionPropertiesFUCHSIA::initialize(const BufferCollectionPropertiesFUCHSIA* 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);
+}
+
+ImageFormatConstraintsInfoFUCHSIA::ImageFormatConstraintsInfoFUCHSIA(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 SysmemColorSpaceFUCHSIA[colorSpaceCount];
+        for (uint32_t i = 0; i < colorSpaceCount; ++i) {
+            pColorSpaces[i].initialize(&in_struct->pColorSpaces[i]);
+        }
+    }
+}
+
+ImageFormatConstraintsInfoFUCHSIA::ImageFormatConstraintsInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA),
+      pNext(nullptr),
+      requiredFormatFeatures(),
+      flags(),
+      sysmemPixelFormat(),
+      colorSpaceCount(),
+      pColorSpaces(nullptr) {}
+
+ImageFormatConstraintsInfoFUCHSIA::ImageFormatConstraintsInfoFUCHSIA(const ImageFormatConstraintsInfoFUCHSIA& 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 SysmemColorSpaceFUCHSIA[colorSpaceCount];
+        for (uint32_t i = 0; i < colorSpaceCount; ++i) {
+            pColorSpaces[i].initialize(&copy_src.pColorSpaces[i]);
+        }
+    }
+}
+
+ImageFormatConstraintsInfoFUCHSIA& ImageFormatConstraintsInfoFUCHSIA::operator=(const ImageFormatConstraintsInfoFUCHSIA& 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 SysmemColorSpaceFUCHSIA[colorSpaceCount];
+        for (uint32_t i = 0; i < colorSpaceCount; ++i) {
+            pColorSpaces[i].initialize(&copy_src.pColorSpaces[i]);
+        }
+    }
+
+    return *this;
+}
+
+ImageFormatConstraintsInfoFUCHSIA::~ImageFormatConstraintsInfoFUCHSIA() {
+    if (pColorSpaces) delete[] pColorSpaces;
+    FreePnextChain(pNext);
+}
+
+void ImageFormatConstraintsInfoFUCHSIA::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 SysmemColorSpaceFUCHSIA[colorSpaceCount];
+        for (uint32_t i = 0; i < colorSpaceCount; ++i) {
+            pColorSpaces[i].initialize(&in_struct->pColorSpaces[i]);
+        }
+    }
+}
+
+void ImageFormatConstraintsInfoFUCHSIA::initialize(const ImageFormatConstraintsInfoFUCHSIA* 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 SysmemColorSpaceFUCHSIA[colorSpaceCount];
+        for (uint32_t i = 0; i < colorSpaceCount; ++i) {
+            pColorSpaces[i].initialize(&copy_src->pColorSpaces[i]);
+        }
+    }
+}
+
+ImageConstraintsInfoFUCHSIA::ImageConstraintsInfoFUCHSIA(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 ImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount];
+        for (uint32_t i = 0; i < formatConstraintsCount; ++i) {
+            pFormatConstraints[i].initialize(&in_struct->pFormatConstraints[i]);
+        }
+    }
+}
+
+ImageConstraintsInfoFUCHSIA::ImageConstraintsInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA),
+      pNext(nullptr),
+      formatConstraintsCount(),
+      pFormatConstraints(nullptr),
+      flags() {}
+
+ImageConstraintsInfoFUCHSIA::ImageConstraintsInfoFUCHSIA(const ImageConstraintsInfoFUCHSIA& 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 ImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount];
+        for (uint32_t i = 0; i < formatConstraintsCount; ++i) {
+            pFormatConstraints[i].initialize(&copy_src.pFormatConstraints[i]);
+        }
+    }
+}
+
+ImageConstraintsInfoFUCHSIA& ImageConstraintsInfoFUCHSIA::operator=(const ImageConstraintsInfoFUCHSIA& 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 ImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount];
+        for (uint32_t i = 0; i < formatConstraintsCount; ++i) {
+            pFormatConstraints[i].initialize(&copy_src.pFormatConstraints[i]);
+        }
+    }
+
+    return *this;
+}
+
+ImageConstraintsInfoFUCHSIA::~ImageConstraintsInfoFUCHSIA() {
+    if (pFormatConstraints) delete[] pFormatConstraints;
+    FreePnextChain(pNext);
+}
+
+void ImageConstraintsInfoFUCHSIA::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 ImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount];
+        for (uint32_t i = 0; i < formatConstraintsCount; ++i) {
+            pFormatConstraints[i].initialize(&in_struct->pFormatConstraints[i]);
+        }
+    }
+}
+
+void ImageConstraintsInfoFUCHSIA::initialize(const ImageConstraintsInfoFUCHSIA* 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 ImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount];
+        for (uint32_t i = 0; i < formatConstraintsCount; ++i) {
+            pFormatConstraints[i].initialize(&copy_src->pFormatConstraints[i]);
+        }
+    }
+}
+#endif  // VK_USE_PLATFORM_FUCHSIA
+
+SubpassShadingPipelineCreateInfoHUAWEI::SubpassShadingPipelineCreateInfoHUAWEI(
+    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);
+    }
+}
+
+SubpassShadingPipelineCreateInfoHUAWEI::SubpassShadingPipelineCreateInfoHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI), pNext(nullptr), renderPass(), subpass() {}
+
+SubpassShadingPipelineCreateInfoHUAWEI::SubpassShadingPipelineCreateInfoHUAWEI(
+    const SubpassShadingPipelineCreateInfoHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    renderPass = copy_src.renderPass;
+    subpass = copy_src.subpass;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SubpassShadingPipelineCreateInfoHUAWEI& SubpassShadingPipelineCreateInfoHUAWEI::operator=(
+    const SubpassShadingPipelineCreateInfoHUAWEI& 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;
+}
+
+SubpassShadingPipelineCreateInfoHUAWEI::~SubpassShadingPipelineCreateInfoHUAWEI() { FreePnextChain(pNext); }
+
+void SubpassShadingPipelineCreateInfoHUAWEI::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 SubpassShadingPipelineCreateInfoHUAWEI::initialize(const SubpassShadingPipelineCreateInfoHUAWEI* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    renderPass = copy_src->renderPass;
+    subpass = copy_src->subpass;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceSubpassShadingFeaturesHUAWEI::PhysicalDeviceSubpassShadingFeaturesHUAWEI(
+    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);
+    }
+}
+
+PhysicalDeviceSubpassShadingFeaturesHUAWEI::PhysicalDeviceSubpassShadingFeaturesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI), pNext(nullptr), subpassShading() {}
+
+PhysicalDeviceSubpassShadingFeaturesHUAWEI::PhysicalDeviceSubpassShadingFeaturesHUAWEI(
+    const PhysicalDeviceSubpassShadingFeaturesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    subpassShading = copy_src.subpassShading;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSubpassShadingFeaturesHUAWEI& PhysicalDeviceSubpassShadingFeaturesHUAWEI::operator=(
+    const PhysicalDeviceSubpassShadingFeaturesHUAWEI& 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;
+}
+
+PhysicalDeviceSubpassShadingFeaturesHUAWEI::~PhysicalDeviceSubpassShadingFeaturesHUAWEI() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSubpassShadingFeaturesHUAWEI::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 PhysicalDeviceSubpassShadingFeaturesHUAWEI::initialize(const PhysicalDeviceSubpassShadingFeaturesHUAWEI* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subpassShading = copy_src->subpassShading;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceSubpassShadingPropertiesHUAWEI::PhysicalDeviceSubpassShadingPropertiesHUAWEI(
+    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);
+    }
+}
+
+PhysicalDeviceSubpassShadingPropertiesHUAWEI::PhysicalDeviceSubpassShadingPropertiesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI),
+      pNext(nullptr),
+      maxSubpassShadingWorkgroupSizeAspectRatio() {}
+
+PhysicalDeviceSubpassShadingPropertiesHUAWEI::PhysicalDeviceSubpassShadingPropertiesHUAWEI(
+    const PhysicalDeviceSubpassShadingPropertiesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    maxSubpassShadingWorkgroupSizeAspectRatio = copy_src.maxSubpassShadingWorkgroupSizeAspectRatio;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSubpassShadingPropertiesHUAWEI& PhysicalDeviceSubpassShadingPropertiesHUAWEI::operator=(
+    const PhysicalDeviceSubpassShadingPropertiesHUAWEI& 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;
+}
+
+PhysicalDeviceSubpassShadingPropertiesHUAWEI::~PhysicalDeviceSubpassShadingPropertiesHUAWEI() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSubpassShadingPropertiesHUAWEI::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 PhysicalDeviceSubpassShadingPropertiesHUAWEI::initialize(const PhysicalDeviceSubpassShadingPropertiesHUAWEI* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxSubpassShadingWorkgroupSizeAspectRatio = copy_src->maxSubpassShadingWorkgroupSizeAspectRatio;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceInvocationMaskFeaturesHUAWEI::PhysicalDeviceInvocationMaskFeaturesHUAWEI(
+    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);
+    }
+}
+
+PhysicalDeviceInvocationMaskFeaturesHUAWEI::PhysicalDeviceInvocationMaskFeaturesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI), pNext(nullptr), invocationMask() {}
+
+PhysicalDeviceInvocationMaskFeaturesHUAWEI::PhysicalDeviceInvocationMaskFeaturesHUAWEI(
+    const PhysicalDeviceInvocationMaskFeaturesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    invocationMask = copy_src.invocationMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceInvocationMaskFeaturesHUAWEI& PhysicalDeviceInvocationMaskFeaturesHUAWEI::operator=(
+    const PhysicalDeviceInvocationMaskFeaturesHUAWEI& 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;
+}
+
+PhysicalDeviceInvocationMaskFeaturesHUAWEI::~PhysicalDeviceInvocationMaskFeaturesHUAWEI() { FreePnextChain(pNext); }
+
+void PhysicalDeviceInvocationMaskFeaturesHUAWEI::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 PhysicalDeviceInvocationMaskFeaturesHUAWEI::initialize(const PhysicalDeviceInvocationMaskFeaturesHUAWEI* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    invocationMask = copy_src->invocationMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MemoryGetRemoteAddressInfoNV::MemoryGetRemoteAddressInfoNV(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);
+    }
+}
+
+MemoryGetRemoteAddressInfoNV::MemoryGetRemoteAddressInfoNV()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV), pNext(nullptr), memory(), handleType() {}
+
+MemoryGetRemoteAddressInfoNV::MemoryGetRemoteAddressInfoNV(const MemoryGetRemoteAddressInfoNV& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+MemoryGetRemoteAddressInfoNV& MemoryGetRemoteAddressInfoNV::operator=(const MemoryGetRemoteAddressInfoNV& 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;
+}
+
+MemoryGetRemoteAddressInfoNV::~MemoryGetRemoteAddressInfoNV() { FreePnextChain(pNext); }
+
+void MemoryGetRemoteAddressInfoNV::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 MemoryGetRemoteAddressInfoNV::initialize(const MemoryGetRemoteAddressInfoNV* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceExternalMemoryRDMAFeaturesNV::PhysicalDeviceExternalMemoryRDMAFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceExternalMemoryRDMAFeaturesNV::PhysicalDeviceExternalMemoryRDMAFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV), pNext(nullptr), externalMemoryRDMA() {}
+
+PhysicalDeviceExternalMemoryRDMAFeaturesNV::PhysicalDeviceExternalMemoryRDMAFeaturesNV(
+    const PhysicalDeviceExternalMemoryRDMAFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    externalMemoryRDMA = copy_src.externalMemoryRDMA;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExternalMemoryRDMAFeaturesNV& PhysicalDeviceExternalMemoryRDMAFeaturesNV::operator=(
+    const PhysicalDeviceExternalMemoryRDMAFeaturesNV& 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;
+}
+
+PhysicalDeviceExternalMemoryRDMAFeaturesNV::~PhysicalDeviceExternalMemoryRDMAFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExternalMemoryRDMAFeaturesNV::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 PhysicalDeviceExternalMemoryRDMAFeaturesNV::initialize(const PhysicalDeviceExternalMemoryRDMAFeaturesNV* 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
+
+ScreenSurfaceCreateInfoQNX::ScreenSurfaceCreateInfoQNX(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);
+    }
+}
+
+ScreenSurfaceCreateInfoQNX::ScreenSurfaceCreateInfoQNX()
+    : sType(VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX), pNext(nullptr), flags(), context(nullptr), window(nullptr) {}
+
+ScreenSurfaceCreateInfoQNX::ScreenSurfaceCreateInfoQNX(const ScreenSurfaceCreateInfoQNX& 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);
+    }
+}
+
+ScreenSurfaceCreateInfoQNX& ScreenSurfaceCreateInfoQNX::operator=(const ScreenSurfaceCreateInfoQNX& 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;
+}
+
+ScreenSurfaceCreateInfoQNX::~ScreenSurfaceCreateInfoQNX() {
+    if (context) delete context;
+    if (window) delete window;
+    FreePnextChain(pNext);
+}
+
+void ScreenSurfaceCreateInfoQNX::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 ScreenSurfaceCreateInfoQNX::initialize(const ScreenSurfaceCreateInfoQNX* 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
+
+PhysicalDeviceDisplacementMicromapFeaturesNV::PhysicalDeviceDisplacementMicromapFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceDisplacementMicromapFeaturesNV::PhysicalDeviceDisplacementMicromapFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV), pNext(nullptr), displacementMicromap() {}
+
+PhysicalDeviceDisplacementMicromapFeaturesNV::PhysicalDeviceDisplacementMicromapFeaturesNV(
+    const PhysicalDeviceDisplacementMicromapFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    displacementMicromap = copy_src.displacementMicromap;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDisplacementMicromapFeaturesNV& PhysicalDeviceDisplacementMicromapFeaturesNV::operator=(
+    const PhysicalDeviceDisplacementMicromapFeaturesNV& 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;
+}
+
+PhysicalDeviceDisplacementMicromapFeaturesNV::~PhysicalDeviceDisplacementMicromapFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDisplacementMicromapFeaturesNV::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 PhysicalDeviceDisplacementMicromapFeaturesNV::initialize(const PhysicalDeviceDisplacementMicromapFeaturesNV* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displacementMicromap = copy_src->displacementMicromap;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDisplacementMicromapPropertiesNV::PhysicalDeviceDisplacementMicromapPropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceDisplacementMicromapPropertiesNV::PhysicalDeviceDisplacementMicromapPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV),
+      pNext(nullptr),
+      maxDisplacementMicromapSubdivisionLevel() {}
+
+PhysicalDeviceDisplacementMicromapPropertiesNV::PhysicalDeviceDisplacementMicromapPropertiesNV(
+    const PhysicalDeviceDisplacementMicromapPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    maxDisplacementMicromapSubdivisionLevel = copy_src.maxDisplacementMicromapSubdivisionLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDisplacementMicromapPropertiesNV& PhysicalDeviceDisplacementMicromapPropertiesNV::operator=(
+    const PhysicalDeviceDisplacementMicromapPropertiesNV& 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;
+}
+
+PhysicalDeviceDisplacementMicromapPropertiesNV::~PhysicalDeviceDisplacementMicromapPropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceDisplacementMicromapPropertiesNV::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 PhysicalDeviceDisplacementMicromapPropertiesNV::initialize(const PhysicalDeviceDisplacementMicromapPropertiesNV* 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
+
+PhysicalDeviceClusterCullingShaderFeaturesHUAWEI::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    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);
+    }
+}
+
+PhysicalDeviceClusterCullingShaderFeaturesHUAWEI::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI),
+      pNext(nullptr),
+      clustercullingShader(),
+      multiviewClusterCullingShader() {}
+
+PhysicalDeviceClusterCullingShaderFeaturesHUAWEI::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    const PhysicalDeviceClusterCullingShaderFeaturesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    clustercullingShader = copy_src.clustercullingShader;
+    multiviewClusterCullingShader = copy_src.multiviewClusterCullingShader;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceClusterCullingShaderFeaturesHUAWEI& PhysicalDeviceClusterCullingShaderFeaturesHUAWEI::operator=(
+    const PhysicalDeviceClusterCullingShaderFeaturesHUAWEI& 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;
+}
+
+PhysicalDeviceClusterCullingShaderFeaturesHUAWEI::~PhysicalDeviceClusterCullingShaderFeaturesHUAWEI() { FreePnextChain(pNext); }
+
+void PhysicalDeviceClusterCullingShaderFeaturesHUAWEI::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 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI::initialize(const PhysicalDeviceClusterCullingShaderFeaturesHUAWEI* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    clustercullingShader = copy_src->clustercullingShader;
+    multiviewClusterCullingShader = copy_src->multiviewClusterCullingShader;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceClusterCullingShaderPropertiesHUAWEI::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    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];
+    }
+}
+
+PhysicalDeviceClusterCullingShaderPropertiesHUAWEI::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI),
+      pNext(nullptr),
+      maxOutputClusterCount(),
+      indirectBufferOffsetAlignment() {}
+
+PhysicalDeviceClusterCullingShaderPropertiesHUAWEI::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    const PhysicalDeviceClusterCullingShaderPropertiesHUAWEI& 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];
+    }
+}
+
+PhysicalDeviceClusterCullingShaderPropertiesHUAWEI& PhysicalDeviceClusterCullingShaderPropertiesHUAWEI::operator=(
+    const PhysicalDeviceClusterCullingShaderPropertiesHUAWEI& 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;
+}
+
+PhysicalDeviceClusterCullingShaderPropertiesHUAWEI::~PhysicalDeviceClusterCullingShaderPropertiesHUAWEI() { FreePnextChain(pNext); }
+
+void PhysicalDeviceClusterCullingShaderPropertiesHUAWEI::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 PhysicalDeviceClusterCullingShaderPropertiesHUAWEI::initialize(
+    const PhysicalDeviceClusterCullingShaderPropertiesHUAWEI* 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];
+    }
+}
+
+PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(
+    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);
+    }
+}
+
+PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI), pNext(nullptr), clusterShadingRate() {}
+
+PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(
+    const PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    clusterShadingRate = copy_src.clusterShadingRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::operator=(
+    const PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& 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;
+}
+
+PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::~PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::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 PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::initialize(
+    const PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    clusterShadingRate = copy_src->clusterShadingRate;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderCorePropertiesARM::PhysicalDeviceShaderCorePropertiesARM(
+    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);
+    }
+}
+
+PhysicalDeviceShaderCorePropertiesARM::PhysicalDeviceShaderCorePropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM), pNext(nullptr), pixelRate(), texelRate(), fmaRate() {}
+
+PhysicalDeviceShaderCorePropertiesARM::PhysicalDeviceShaderCorePropertiesARM(
+    const PhysicalDeviceShaderCorePropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    pixelRate = copy_src.pixelRate;
+    texelRate = copy_src.texelRate;
+    fmaRate = copy_src.fmaRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderCorePropertiesARM& PhysicalDeviceShaderCorePropertiesARM::operator=(
+    const PhysicalDeviceShaderCorePropertiesARM& 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;
+}
+
+PhysicalDeviceShaderCorePropertiesARM::~PhysicalDeviceShaderCorePropertiesARM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderCorePropertiesARM::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 PhysicalDeviceShaderCorePropertiesARM::initialize(const PhysicalDeviceShaderCorePropertiesARM* 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);
+}
+
+DeviceQueueShaderCoreControlCreateInfoARM::DeviceQueueShaderCoreControlCreateInfoARM(
+    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);
+    }
+}
+
+DeviceQueueShaderCoreControlCreateInfoARM::DeviceQueueShaderCoreControlCreateInfoARM()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM), pNext(nullptr), shaderCoreCount() {}
+
+DeviceQueueShaderCoreControlCreateInfoARM::DeviceQueueShaderCoreControlCreateInfoARM(
+    const DeviceQueueShaderCoreControlCreateInfoARM& copy_src) {
+    sType = copy_src.sType;
+    shaderCoreCount = copy_src.shaderCoreCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DeviceQueueShaderCoreControlCreateInfoARM& DeviceQueueShaderCoreControlCreateInfoARM::operator=(
+    const DeviceQueueShaderCoreControlCreateInfoARM& 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;
+}
+
+DeviceQueueShaderCoreControlCreateInfoARM::~DeviceQueueShaderCoreControlCreateInfoARM() { FreePnextChain(pNext); }
+
+void DeviceQueueShaderCoreControlCreateInfoARM::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 DeviceQueueShaderCoreControlCreateInfoARM::initialize(const DeviceQueueShaderCoreControlCreateInfoARM* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderCoreCount = copy_src->shaderCoreCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceSchedulingControlsFeaturesARM::PhysicalDeviceSchedulingControlsFeaturesARM(
+    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);
+    }
+}
+
+PhysicalDeviceSchedulingControlsFeaturesARM::PhysicalDeviceSchedulingControlsFeaturesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM), pNext(nullptr), schedulingControls() {}
+
+PhysicalDeviceSchedulingControlsFeaturesARM::PhysicalDeviceSchedulingControlsFeaturesARM(
+    const PhysicalDeviceSchedulingControlsFeaturesARM& copy_src) {
+    sType = copy_src.sType;
+    schedulingControls = copy_src.schedulingControls;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSchedulingControlsFeaturesARM& PhysicalDeviceSchedulingControlsFeaturesARM::operator=(
+    const PhysicalDeviceSchedulingControlsFeaturesARM& 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;
+}
+
+PhysicalDeviceSchedulingControlsFeaturesARM::~PhysicalDeviceSchedulingControlsFeaturesARM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSchedulingControlsFeaturesARM::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 PhysicalDeviceSchedulingControlsFeaturesARM::initialize(const PhysicalDeviceSchedulingControlsFeaturesARM* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    schedulingControls = copy_src->schedulingControls;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceSchedulingControlsPropertiesARM::PhysicalDeviceSchedulingControlsPropertiesARM(
+    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);
+    }
+}
+
+PhysicalDeviceSchedulingControlsPropertiesARM::PhysicalDeviceSchedulingControlsPropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM), pNext(nullptr), schedulingControlsFlags() {}
+
+PhysicalDeviceSchedulingControlsPropertiesARM::PhysicalDeviceSchedulingControlsPropertiesARM(
+    const PhysicalDeviceSchedulingControlsPropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    schedulingControlsFlags = copy_src.schedulingControlsFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceSchedulingControlsPropertiesARM& PhysicalDeviceSchedulingControlsPropertiesARM::operator=(
+    const PhysicalDeviceSchedulingControlsPropertiesARM& 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;
+}
+
+PhysicalDeviceSchedulingControlsPropertiesARM::~PhysicalDeviceSchedulingControlsPropertiesARM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceSchedulingControlsPropertiesARM::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 PhysicalDeviceSchedulingControlsPropertiesARM::initialize(const PhysicalDeviceSchedulingControlsPropertiesARM* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    schedulingControlsFlags = copy_src->schedulingControlsFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    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);
+    }
+}
+
+PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE),
+      pNext(nullptr),
+      descriptorSetHostMapping() {}
+
+PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    const PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& copy_src) {
+    sType = copy_src.sType;
+    descriptorSetHostMapping = copy_src.descriptorSetHostMapping;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::operator=(
+    const PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& 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;
+}
+
+PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::~PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::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 PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::initialize(
+    const PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorSetHostMapping = copy_src->descriptorSetHostMapping;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DescriptorSetBindingReferenceVALVE::DescriptorSetBindingReferenceVALVE(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);
+    }
+}
+
+DescriptorSetBindingReferenceVALVE::DescriptorSetBindingReferenceVALVE()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE), pNext(nullptr), descriptorSetLayout(), binding() {}
+
+DescriptorSetBindingReferenceVALVE::DescriptorSetBindingReferenceVALVE(const DescriptorSetBindingReferenceVALVE& copy_src) {
+    sType = copy_src.sType;
+    descriptorSetLayout = copy_src.descriptorSetLayout;
+    binding = copy_src.binding;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DescriptorSetBindingReferenceVALVE& DescriptorSetBindingReferenceVALVE::operator=(
+    const DescriptorSetBindingReferenceVALVE& 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;
+}
+
+DescriptorSetBindingReferenceVALVE::~DescriptorSetBindingReferenceVALVE() { FreePnextChain(pNext); }
+
+void DescriptorSetBindingReferenceVALVE::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 DescriptorSetBindingReferenceVALVE::initialize(const DescriptorSetBindingReferenceVALVE* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorSetLayout = copy_src->descriptorSetLayout;
+    binding = copy_src->binding;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DescriptorSetLayoutHostMappingInfoVALVE::DescriptorSetLayoutHostMappingInfoVALVE(
+    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);
+    }
+}
+
+DescriptorSetLayoutHostMappingInfoVALVE::DescriptorSetLayoutHostMappingInfoVALVE()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE),
+      pNext(nullptr),
+      descriptorOffset(),
+      descriptorSize() {}
+
+DescriptorSetLayoutHostMappingInfoVALVE::DescriptorSetLayoutHostMappingInfoVALVE(
+    const DescriptorSetLayoutHostMappingInfoVALVE& copy_src) {
+    sType = copy_src.sType;
+    descriptorOffset = copy_src.descriptorOffset;
+    descriptorSize = copy_src.descriptorSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DescriptorSetLayoutHostMappingInfoVALVE& DescriptorSetLayoutHostMappingInfoVALVE::operator=(
+    const DescriptorSetLayoutHostMappingInfoVALVE& 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;
+}
+
+DescriptorSetLayoutHostMappingInfoVALVE::~DescriptorSetLayoutHostMappingInfoVALVE() { FreePnextChain(pNext); }
+
+void DescriptorSetLayoutHostMappingInfoVALVE::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 DescriptorSetLayoutHostMappingInfoVALVE::initialize(const DescriptorSetLayoutHostMappingInfoVALVE* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorOffset = copy_src->descriptorOffset;
+    descriptorSize = copy_src->descriptorSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceRenderPassStripedFeaturesARM::PhysicalDeviceRenderPassStripedFeaturesARM(
+    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);
+    }
+}
+
+PhysicalDeviceRenderPassStripedFeaturesARM::PhysicalDeviceRenderPassStripedFeaturesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM), pNext(nullptr), renderPassStriped() {}
+
+PhysicalDeviceRenderPassStripedFeaturesARM::PhysicalDeviceRenderPassStripedFeaturesARM(
+    const PhysicalDeviceRenderPassStripedFeaturesARM& copy_src) {
+    sType = copy_src.sType;
+    renderPassStriped = copy_src.renderPassStriped;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRenderPassStripedFeaturesARM& PhysicalDeviceRenderPassStripedFeaturesARM::operator=(
+    const PhysicalDeviceRenderPassStripedFeaturesARM& 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;
+}
+
+PhysicalDeviceRenderPassStripedFeaturesARM::~PhysicalDeviceRenderPassStripedFeaturesARM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRenderPassStripedFeaturesARM::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 PhysicalDeviceRenderPassStripedFeaturesARM::initialize(const PhysicalDeviceRenderPassStripedFeaturesARM* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    renderPassStriped = copy_src->renderPassStriped;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceRenderPassStripedPropertiesARM::PhysicalDeviceRenderPassStripedPropertiesARM(
+    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);
+    }
+}
+
+PhysicalDeviceRenderPassStripedPropertiesARM::PhysicalDeviceRenderPassStripedPropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM),
+      pNext(nullptr),
+      renderPassStripeGranularity(),
+      maxRenderPassStripes() {}
+
+PhysicalDeviceRenderPassStripedPropertiesARM::PhysicalDeviceRenderPassStripedPropertiesARM(
+    const PhysicalDeviceRenderPassStripedPropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    renderPassStripeGranularity = copy_src.renderPassStripeGranularity;
+    maxRenderPassStripes = copy_src.maxRenderPassStripes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRenderPassStripedPropertiesARM& PhysicalDeviceRenderPassStripedPropertiesARM::operator=(
+    const PhysicalDeviceRenderPassStripedPropertiesARM& 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;
+}
+
+PhysicalDeviceRenderPassStripedPropertiesARM::~PhysicalDeviceRenderPassStripedPropertiesARM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRenderPassStripedPropertiesARM::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 PhysicalDeviceRenderPassStripedPropertiesARM::initialize(const PhysicalDeviceRenderPassStripedPropertiesARM* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    renderPassStripeGranularity = copy_src->renderPassStripeGranularity;
+    maxRenderPassStripes = copy_src->maxRenderPassStripes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+RenderPassStripeInfoARM::RenderPassStripeInfoARM(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);
+    }
+}
+
+RenderPassStripeInfoARM::RenderPassStripeInfoARM()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM), pNext(nullptr), stripeArea() {}
+
+RenderPassStripeInfoARM::RenderPassStripeInfoARM(const RenderPassStripeInfoARM& copy_src) {
+    sType = copy_src.sType;
+    stripeArea = copy_src.stripeArea;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+RenderPassStripeInfoARM& RenderPassStripeInfoARM::operator=(const RenderPassStripeInfoARM& 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;
+}
+
+RenderPassStripeInfoARM::~RenderPassStripeInfoARM() { FreePnextChain(pNext); }
+
+void RenderPassStripeInfoARM::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 RenderPassStripeInfoARM::initialize(const RenderPassStripeInfoARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stripeArea = copy_src->stripeArea;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+RenderPassStripeBeginInfoARM::RenderPassStripeBeginInfoARM(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 RenderPassStripeInfoARM[stripeInfoCount];
+        for (uint32_t i = 0; i < stripeInfoCount; ++i) {
+            pStripeInfos[i].initialize(&in_struct->pStripeInfos[i]);
+        }
+    }
+}
+
+RenderPassStripeBeginInfoARM::RenderPassStripeBeginInfoARM()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM), pNext(nullptr), stripeInfoCount(), pStripeInfos(nullptr) {}
+
+RenderPassStripeBeginInfoARM::RenderPassStripeBeginInfoARM(const RenderPassStripeBeginInfoARM& copy_src) {
+    sType = copy_src.sType;
+    stripeInfoCount = copy_src.stripeInfoCount;
+    pStripeInfos = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stripeInfoCount && copy_src.pStripeInfos) {
+        pStripeInfos = new RenderPassStripeInfoARM[stripeInfoCount];
+        for (uint32_t i = 0; i < stripeInfoCount; ++i) {
+            pStripeInfos[i].initialize(&copy_src.pStripeInfos[i]);
+        }
+    }
+}
+
+RenderPassStripeBeginInfoARM& RenderPassStripeBeginInfoARM::operator=(const RenderPassStripeBeginInfoARM& 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 RenderPassStripeInfoARM[stripeInfoCount];
+        for (uint32_t i = 0; i < stripeInfoCount; ++i) {
+            pStripeInfos[i].initialize(&copy_src.pStripeInfos[i]);
+        }
+    }
+
+    return *this;
+}
+
+RenderPassStripeBeginInfoARM::~RenderPassStripeBeginInfoARM() {
+    if (pStripeInfos) delete[] pStripeInfos;
+    FreePnextChain(pNext);
+}
+
+void RenderPassStripeBeginInfoARM::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 RenderPassStripeInfoARM[stripeInfoCount];
+        for (uint32_t i = 0; i < stripeInfoCount; ++i) {
+            pStripeInfos[i].initialize(&in_struct->pStripeInfos[i]);
+        }
+    }
+}
+
+void RenderPassStripeBeginInfoARM::initialize(const RenderPassStripeBeginInfoARM* 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 RenderPassStripeInfoARM[stripeInfoCount];
+        for (uint32_t i = 0; i < stripeInfoCount; ++i) {
+            pStripeInfos[i].initialize(&copy_src->pStripeInfos[i]);
+        }
+    }
+}
+
+RenderPassStripeSubmitInfoARM::RenderPassStripeSubmitInfoARM(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 SemaphoreSubmitInfo[stripeSemaphoreInfoCount];
+        for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) {
+            pStripeSemaphoreInfos[i].initialize(&in_struct->pStripeSemaphoreInfos[i]);
+        }
+    }
+}
+
+RenderPassStripeSubmitInfoARM::RenderPassStripeSubmitInfoARM()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM),
+      pNext(nullptr),
+      stripeSemaphoreInfoCount(),
+      pStripeSemaphoreInfos(nullptr) {}
+
+RenderPassStripeSubmitInfoARM::RenderPassStripeSubmitInfoARM(const RenderPassStripeSubmitInfoARM& copy_src) {
+    sType = copy_src.sType;
+    stripeSemaphoreInfoCount = copy_src.stripeSemaphoreInfoCount;
+    pStripeSemaphoreInfos = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stripeSemaphoreInfoCount && copy_src.pStripeSemaphoreInfos) {
+        pStripeSemaphoreInfos = new SemaphoreSubmitInfo[stripeSemaphoreInfoCount];
+        for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) {
+            pStripeSemaphoreInfos[i].initialize(&copy_src.pStripeSemaphoreInfos[i]);
+        }
+    }
+}
+
+RenderPassStripeSubmitInfoARM& RenderPassStripeSubmitInfoARM::operator=(const RenderPassStripeSubmitInfoARM& 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 SemaphoreSubmitInfo[stripeSemaphoreInfoCount];
+        for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) {
+            pStripeSemaphoreInfos[i].initialize(&copy_src.pStripeSemaphoreInfos[i]);
+        }
+    }
+
+    return *this;
+}
+
+RenderPassStripeSubmitInfoARM::~RenderPassStripeSubmitInfoARM() {
+    if (pStripeSemaphoreInfos) delete[] pStripeSemaphoreInfos;
+    FreePnextChain(pNext);
+}
+
+void RenderPassStripeSubmitInfoARM::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 SemaphoreSubmitInfo[stripeSemaphoreInfoCount];
+        for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) {
+            pStripeSemaphoreInfos[i].initialize(&in_struct->pStripeSemaphoreInfos[i]);
+        }
+    }
+}
+
+void RenderPassStripeSubmitInfoARM::initialize(const RenderPassStripeSubmitInfoARM* 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 SemaphoreSubmitInfo[stripeSemaphoreInfoCount];
+        for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) {
+            pStripeSemaphoreInfos[i].initialize(&copy_src->pStripeSemaphoreInfos[i]);
+        }
+    }
+}
+
+PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM),
+      pNext(nullptr),
+      fragmentDensityMapOffset() {}
+
+PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    const PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityMapOffset = copy_src.fragmentDensityMapOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::operator=(
+    const PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& 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;
+}
+
+PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::~PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::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 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::initialize(
+    const PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityMapOffset = copy_src->fragmentDensityMapOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    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);
+    }
+}
+
+PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM),
+      pNext(nullptr),
+      fragmentDensityOffsetGranularity() {}
+
+PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    const PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityOffsetGranularity = copy_src.fragmentDensityOffsetGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::operator=(
+    const PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& 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;
+}
+
+PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::~PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::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 PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::initialize(
+    const PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityOffsetGranularity = copy_src->fragmentDensityOffsetGranularity;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SubpassFragmentDensityMapOffsetEndInfoQCOM::SubpassFragmentDensityMapOffsetEndInfoQCOM(
+    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);
+    }
+}
+
+SubpassFragmentDensityMapOffsetEndInfoQCOM::SubpassFragmentDensityMapOffsetEndInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM),
+      pNext(nullptr),
+      fragmentDensityOffsetCount(),
+      pFragmentDensityOffsets(nullptr) {}
+
+SubpassFragmentDensityMapOffsetEndInfoQCOM::SubpassFragmentDensityMapOffsetEndInfoQCOM(
+    const SubpassFragmentDensityMapOffsetEndInfoQCOM& 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);
+    }
+}
+
+SubpassFragmentDensityMapOffsetEndInfoQCOM& SubpassFragmentDensityMapOffsetEndInfoQCOM::operator=(
+    const SubpassFragmentDensityMapOffsetEndInfoQCOM& 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;
+}
+
+SubpassFragmentDensityMapOffsetEndInfoQCOM::~SubpassFragmentDensityMapOffsetEndInfoQCOM() {
+    if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets;
+    FreePnextChain(pNext);
+}
+
+void SubpassFragmentDensityMapOffsetEndInfoQCOM::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 SubpassFragmentDensityMapOffsetEndInfoQCOM::initialize(const SubpassFragmentDensityMapOffsetEndInfoQCOM* 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);
+    }
+}
+
+PhysicalDeviceCopyMemoryIndirectFeaturesNV::PhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceCopyMemoryIndirectFeaturesNV::PhysicalDeviceCopyMemoryIndirectFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV), pNext(nullptr), indirectCopy() {}
+
+PhysicalDeviceCopyMemoryIndirectFeaturesNV::PhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    const PhysicalDeviceCopyMemoryIndirectFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    indirectCopy = copy_src.indirectCopy;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCopyMemoryIndirectFeaturesNV& PhysicalDeviceCopyMemoryIndirectFeaturesNV::operator=(
+    const PhysicalDeviceCopyMemoryIndirectFeaturesNV& 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;
+}
+
+PhysicalDeviceCopyMemoryIndirectFeaturesNV::~PhysicalDeviceCopyMemoryIndirectFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCopyMemoryIndirectFeaturesNV::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 PhysicalDeviceCopyMemoryIndirectFeaturesNV::initialize(const PhysicalDeviceCopyMemoryIndirectFeaturesNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    indirectCopy = copy_src->indirectCopy;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceCopyMemoryIndirectPropertiesNV::PhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceCopyMemoryIndirectPropertiesNV::PhysicalDeviceCopyMemoryIndirectPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV), pNext(nullptr), supportedQueues() {}
+
+PhysicalDeviceCopyMemoryIndirectPropertiesNV::PhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    const PhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    supportedQueues = copy_src.supportedQueues;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCopyMemoryIndirectPropertiesNV& PhysicalDeviceCopyMemoryIndirectPropertiesNV::operator=(
+    const PhysicalDeviceCopyMemoryIndirectPropertiesNV& 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;
+}
+
+PhysicalDeviceCopyMemoryIndirectPropertiesNV::~PhysicalDeviceCopyMemoryIndirectPropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCopyMemoryIndirectPropertiesNV::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 PhysicalDeviceCopyMemoryIndirectPropertiesNV::initialize(const PhysicalDeviceCopyMemoryIndirectPropertiesNV* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    supportedQueues = copy_src->supportedQueues;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMemoryDecompressionFeaturesNV::PhysicalDeviceMemoryDecompressionFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceMemoryDecompressionFeaturesNV::PhysicalDeviceMemoryDecompressionFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV), pNext(nullptr), memoryDecompression() {}
+
+PhysicalDeviceMemoryDecompressionFeaturesNV::PhysicalDeviceMemoryDecompressionFeaturesNV(
+    const PhysicalDeviceMemoryDecompressionFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    memoryDecompression = copy_src.memoryDecompression;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMemoryDecompressionFeaturesNV& PhysicalDeviceMemoryDecompressionFeaturesNV::operator=(
+    const PhysicalDeviceMemoryDecompressionFeaturesNV& 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;
+}
+
+PhysicalDeviceMemoryDecompressionFeaturesNV::~PhysicalDeviceMemoryDecompressionFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMemoryDecompressionFeaturesNV::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 PhysicalDeviceMemoryDecompressionFeaturesNV::initialize(const PhysicalDeviceMemoryDecompressionFeaturesNV* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryDecompression = copy_src->memoryDecompression;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMemoryDecompressionPropertiesNV::PhysicalDeviceMemoryDecompressionPropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceMemoryDecompressionPropertiesNV::PhysicalDeviceMemoryDecompressionPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV),
+      pNext(nullptr),
+      decompressionMethods(),
+      maxDecompressionIndirectCount() {}
+
+PhysicalDeviceMemoryDecompressionPropertiesNV::PhysicalDeviceMemoryDecompressionPropertiesNV(
+    const PhysicalDeviceMemoryDecompressionPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    decompressionMethods = copy_src.decompressionMethods;
+    maxDecompressionIndirectCount = copy_src.maxDecompressionIndirectCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMemoryDecompressionPropertiesNV& PhysicalDeviceMemoryDecompressionPropertiesNV::operator=(
+    const PhysicalDeviceMemoryDecompressionPropertiesNV& 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;
+}
+
+PhysicalDeviceMemoryDecompressionPropertiesNV::~PhysicalDeviceMemoryDecompressionPropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceMemoryDecompressionPropertiesNV::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 PhysicalDeviceMemoryDecompressionPropertiesNV::initialize(const PhysicalDeviceMemoryDecompressionPropertiesNV* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    decompressionMethods = copy_src->decompressionMethods;
+    maxDecompressionIndirectCount = copy_src->maxDecompressionIndirectCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV),
+      pNext(nullptr),
+      deviceGeneratedCompute(),
+      deviceGeneratedComputePipelines(),
+      deviceGeneratedComputeCaptureReplay() {}
+
+PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(
+    const PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    deviceGeneratedCompute = copy_src.deviceGeneratedCompute;
+    deviceGeneratedComputePipelines = copy_src.deviceGeneratedComputePipelines;
+    deviceGeneratedComputeCaptureReplay = copy_src.deviceGeneratedComputeCaptureReplay;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::operator=(
+    const PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& 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;
+}
+
+PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::~PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::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 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::initialize(
+    const PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* 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);
+}
+
+ComputePipelineIndirectBufferInfoNV::ComputePipelineIndirectBufferInfoNV(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);
+    }
+}
+
+ComputePipelineIndirectBufferInfoNV::ComputePipelineIndirectBufferInfoNV()
+    : sType(VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV),
+      pNext(nullptr),
+      deviceAddress(),
+      size(),
+      pipelineDeviceAddressCaptureReplay() {}
+
+ComputePipelineIndirectBufferInfoNV::ComputePipelineIndirectBufferInfoNV(const ComputePipelineIndirectBufferInfoNV& copy_src) {
+    sType = copy_src.sType;
+    deviceAddress = copy_src.deviceAddress;
+    size = copy_src.size;
+    pipelineDeviceAddressCaptureReplay = copy_src.pipelineDeviceAddressCaptureReplay;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ComputePipelineIndirectBufferInfoNV& ComputePipelineIndirectBufferInfoNV::operator=(
+    const ComputePipelineIndirectBufferInfoNV& 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;
+}
+
+ComputePipelineIndirectBufferInfoNV::~ComputePipelineIndirectBufferInfoNV() { FreePnextChain(pNext); }
+
+void ComputePipelineIndirectBufferInfoNV::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 ComputePipelineIndirectBufferInfoNV::initialize(const ComputePipelineIndirectBufferInfoNV* 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);
+}
+
+PipelineIndirectDeviceAddressInfoNV::PipelineIndirectDeviceAddressInfoNV(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);
+    }
+}
+
+PipelineIndirectDeviceAddressInfoNV::PipelineIndirectDeviceAddressInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV), pNext(nullptr), pipelineBindPoint(), pipeline() {}
+
+PipelineIndirectDeviceAddressInfoNV::PipelineIndirectDeviceAddressInfoNV(const PipelineIndirectDeviceAddressInfoNV& copy_src) {
+    sType = copy_src.sType;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PipelineIndirectDeviceAddressInfoNV& PipelineIndirectDeviceAddressInfoNV::operator=(
+    const PipelineIndirectDeviceAddressInfoNV& 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;
+}
+
+PipelineIndirectDeviceAddressInfoNV::~PipelineIndirectDeviceAddressInfoNV() { FreePnextChain(pNext); }
+
+void PipelineIndirectDeviceAddressInfoNV::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 PipelineIndirectDeviceAddressInfoNV::initialize(const PipelineIndirectDeviceAddressInfoNV* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineBindPoint = copy_src->pipelineBindPoint;
+    pipeline = copy_src->pipeline;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceLinearColorAttachmentFeaturesNV::PhysicalDeviceLinearColorAttachmentFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceLinearColorAttachmentFeaturesNV::PhysicalDeviceLinearColorAttachmentFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV), pNext(nullptr), linearColorAttachment() {}
+
+PhysicalDeviceLinearColorAttachmentFeaturesNV::PhysicalDeviceLinearColorAttachmentFeaturesNV(
+    const PhysicalDeviceLinearColorAttachmentFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    linearColorAttachment = copy_src.linearColorAttachment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceLinearColorAttachmentFeaturesNV& PhysicalDeviceLinearColorAttachmentFeaturesNV::operator=(
+    const PhysicalDeviceLinearColorAttachmentFeaturesNV& 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;
+}
+
+PhysicalDeviceLinearColorAttachmentFeaturesNV::~PhysicalDeviceLinearColorAttachmentFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceLinearColorAttachmentFeaturesNV::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 PhysicalDeviceLinearColorAttachmentFeaturesNV::initialize(const PhysicalDeviceLinearColorAttachmentFeaturesNV* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    linearColorAttachment = copy_src->linearColorAttachment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ImageViewSampleWeightCreateInfoQCOM::ImageViewSampleWeightCreateInfoQCOM(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);
+    }
+}
+
+ImageViewSampleWeightCreateInfoQCOM::ImageViewSampleWeightCreateInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM),
+      pNext(nullptr),
+      filterCenter(),
+      filterSize(),
+      numPhases() {}
+
+ImageViewSampleWeightCreateInfoQCOM::ImageViewSampleWeightCreateInfoQCOM(const ImageViewSampleWeightCreateInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    filterCenter = copy_src.filterCenter;
+    filterSize = copy_src.filterSize;
+    numPhases = copy_src.numPhases;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ImageViewSampleWeightCreateInfoQCOM& ImageViewSampleWeightCreateInfoQCOM::operator=(
+    const ImageViewSampleWeightCreateInfoQCOM& 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;
+}
+
+ImageViewSampleWeightCreateInfoQCOM::~ImageViewSampleWeightCreateInfoQCOM() { FreePnextChain(pNext); }
+
+void ImageViewSampleWeightCreateInfoQCOM::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 ImageViewSampleWeightCreateInfoQCOM::initialize(const ImageViewSampleWeightCreateInfoQCOM* 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);
+}
+
+PhysicalDeviceImageProcessingFeaturesQCOM::PhysicalDeviceImageProcessingFeaturesQCOM(
+    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);
+    }
+}
+
+PhysicalDeviceImageProcessingFeaturesQCOM::PhysicalDeviceImageProcessingFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM),
+      pNext(nullptr),
+      textureSampleWeighted(),
+      textureBoxFilter(),
+      textureBlockMatch() {}
+
+PhysicalDeviceImageProcessingFeaturesQCOM::PhysicalDeviceImageProcessingFeaturesQCOM(
+    const PhysicalDeviceImageProcessingFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    textureSampleWeighted = copy_src.textureSampleWeighted;
+    textureBoxFilter = copy_src.textureBoxFilter;
+    textureBlockMatch = copy_src.textureBlockMatch;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceImageProcessingFeaturesQCOM& PhysicalDeviceImageProcessingFeaturesQCOM::operator=(
+    const PhysicalDeviceImageProcessingFeaturesQCOM& 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;
+}
+
+PhysicalDeviceImageProcessingFeaturesQCOM::~PhysicalDeviceImageProcessingFeaturesQCOM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImageProcessingFeaturesQCOM::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 PhysicalDeviceImageProcessingFeaturesQCOM::initialize(const PhysicalDeviceImageProcessingFeaturesQCOM* 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);
+}
+
+PhysicalDeviceImageProcessingPropertiesQCOM::PhysicalDeviceImageProcessingPropertiesQCOM(
+    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);
+    }
+}
+
+PhysicalDeviceImageProcessingPropertiesQCOM::PhysicalDeviceImageProcessingPropertiesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM),
+      pNext(nullptr),
+      maxWeightFilterPhases(),
+      maxWeightFilterDimension(),
+      maxBlockMatchRegion(),
+      maxBoxFilterBlockSize() {}
+
+PhysicalDeviceImageProcessingPropertiesQCOM::PhysicalDeviceImageProcessingPropertiesQCOM(
+    const PhysicalDeviceImageProcessingPropertiesQCOM& 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);
+}
+
+PhysicalDeviceImageProcessingPropertiesQCOM& PhysicalDeviceImageProcessingPropertiesQCOM::operator=(
+    const PhysicalDeviceImageProcessingPropertiesQCOM& 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;
+}
+
+PhysicalDeviceImageProcessingPropertiesQCOM::~PhysicalDeviceImageProcessingPropertiesQCOM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImageProcessingPropertiesQCOM::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 PhysicalDeviceImageProcessingPropertiesQCOM::initialize(const PhysicalDeviceImageProcessingPropertiesQCOM* 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);
+}
+
+DirectDriverLoadingInfoLUNARG::DirectDriverLoadingInfoLUNARG(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);
+    }
+}
+
+DirectDriverLoadingInfoLUNARG::DirectDriverLoadingInfoLUNARG()
+    : sType(VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG), pNext(nullptr), flags(), pfnGetInstanceProcAddr() {}
+
+DirectDriverLoadingInfoLUNARG::DirectDriverLoadingInfoLUNARG(const DirectDriverLoadingInfoLUNARG& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pfnGetInstanceProcAddr = copy_src.pfnGetInstanceProcAddr;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+DirectDriverLoadingInfoLUNARG& DirectDriverLoadingInfoLUNARG::operator=(const DirectDriverLoadingInfoLUNARG& 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;
+}
+
+DirectDriverLoadingInfoLUNARG::~DirectDriverLoadingInfoLUNARG() { FreePnextChain(pNext); }
+
+void DirectDriverLoadingInfoLUNARG::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 DirectDriverLoadingInfoLUNARG::initialize(const DirectDriverLoadingInfoLUNARG* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pfnGetInstanceProcAddr = copy_src->pfnGetInstanceProcAddr;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+DirectDriverLoadingListLUNARG::DirectDriverLoadingListLUNARG(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 DirectDriverLoadingInfoLUNARG[driverCount];
+        for (uint32_t i = 0; i < driverCount; ++i) {
+            pDrivers[i].initialize(&in_struct->pDrivers[i]);
+        }
+    }
+}
+
+DirectDriverLoadingListLUNARG::DirectDriverLoadingListLUNARG()
+    : sType(VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG), pNext(nullptr), mode(), driverCount(), pDrivers(nullptr) {}
+
+DirectDriverLoadingListLUNARG::DirectDriverLoadingListLUNARG(const DirectDriverLoadingListLUNARG& 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 DirectDriverLoadingInfoLUNARG[driverCount];
+        for (uint32_t i = 0; i < driverCount; ++i) {
+            pDrivers[i].initialize(&copy_src.pDrivers[i]);
+        }
+    }
+}
+
+DirectDriverLoadingListLUNARG& DirectDriverLoadingListLUNARG::operator=(const DirectDriverLoadingListLUNARG& 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 DirectDriverLoadingInfoLUNARG[driverCount];
+        for (uint32_t i = 0; i < driverCount; ++i) {
+            pDrivers[i].initialize(&copy_src.pDrivers[i]);
+        }
+    }
+
+    return *this;
+}
+
+DirectDriverLoadingListLUNARG::~DirectDriverLoadingListLUNARG() {
+    if (pDrivers) delete[] pDrivers;
+    FreePnextChain(pNext);
+}
+
+void DirectDriverLoadingListLUNARG::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 DirectDriverLoadingInfoLUNARG[driverCount];
+        for (uint32_t i = 0; i < driverCount; ++i) {
+            pDrivers[i].initialize(&in_struct->pDrivers[i]);
+        }
+    }
+}
+
+void DirectDriverLoadingListLUNARG::initialize(const DirectDriverLoadingListLUNARG* 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 DirectDriverLoadingInfoLUNARG[driverCount];
+        for (uint32_t i = 0; i < driverCount; ++i) {
+            pDrivers[i].initialize(&copy_src->pDrivers[i]);
+        }
+    }
+}
+
+PhysicalDeviceOpticalFlowFeaturesNV::PhysicalDeviceOpticalFlowFeaturesNV(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);
+    }
+}
+
+PhysicalDeviceOpticalFlowFeaturesNV::PhysicalDeviceOpticalFlowFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV), pNext(nullptr), opticalFlow() {}
+
+PhysicalDeviceOpticalFlowFeaturesNV::PhysicalDeviceOpticalFlowFeaturesNV(const PhysicalDeviceOpticalFlowFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    opticalFlow = copy_src.opticalFlow;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceOpticalFlowFeaturesNV& PhysicalDeviceOpticalFlowFeaturesNV::operator=(
+    const PhysicalDeviceOpticalFlowFeaturesNV& 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;
+}
+
+PhysicalDeviceOpticalFlowFeaturesNV::~PhysicalDeviceOpticalFlowFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceOpticalFlowFeaturesNV::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 PhysicalDeviceOpticalFlowFeaturesNV::initialize(const PhysicalDeviceOpticalFlowFeaturesNV* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    opticalFlow = copy_src->opticalFlow;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceOpticalFlowPropertiesNV::PhysicalDeviceOpticalFlowPropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceOpticalFlowPropertiesNV::PhysicalDeviceOpticalFlowPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV),
+      pNext(nullptr),
+      supportedOutputGridSizes(),
+      supportedHintGridSizes(),
+      hintSupported(),
+      costSupported(),
+      bidirectionalFlowSupported(),
+      globalFlowSupported(),
+      minWidth(),
+      minHeight(),
+      maxWidth(),
+      maxHeight(),
+      maxNumRegionsOfInterest() {}
+
+PhysicalDeviceOpticalFlowPropertiesNV::PhysicalDeviceOpticalFlowPropertiesNV(
+    const PhysicalDeviceOpticalFlowPropertiesNV& 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);
+}
+
+PhysicalDeviceOpticalFlowPropertiesNV& PhysicalDeviceOpticalFlowPropertiesNV::operator=(
+    const PhysicalDeviceOpticalFlowPropertiesNV& 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;
+}
+
+PhysicalDeviceOpticalFlowPropertiesNV::~PhysicalDeviceOpticalFlowPropertiesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceOpticalFlowPropertiesNV::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 PhysicalDeviceOpticalFlowPropertiesNV::initialize(const PhysicalDeviceOpticalFlowPropertiesNV* 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);
+}
+
+OpticalFlowImageFormatInfoNV::OpticalFlowImageFormatInfoNV(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);
+    }
+}
+
+OpticalFlowImageFormatInfoNV::OpticalFlowImageFormatInfoNV()
+    : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV), pNext(nullptr), usage() {}
+
+OpticalFlowImageFormatInfoNV::OpticalFlowImageFormatInfoNV(const OpticalFlowImageFormatInfoNV& copy_src) {
+    sType = copy_src.sType;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+OpticalFlowImageFormatInfoNV& OpticalFlowImageFormatInfoNV::operator=(const OpticalFlowImageFormatInfoNV& 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;
+}
+
+OpticalFlowImageFormatInfoNV::~OpticalFlowImageFormatInfoNV() { FreePnextChain(pNext); }
+
+void OpticalFlowImageFormatInfoNV::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 OpticalFlowImageFormatInfoNV::initialize(const OpticalFlowImageFormatInfoNV* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    usage = copy_src->usage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+OpticalFlowImageFormatPropertiesNV::OpticalFlowImageFormatPropertiesNV(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);
+    }
+}
+
+OpticalFlowImageFormatPropertiesNV::OpticalFlowImageFormatPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV), pNext(nullptr), format() {}
+
+OpticalFlowImageFormatPropertiesNV::OpticalFlowImageFormatPropertiesNV(const OpticalFlowImageFormatPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    format = copy_src.format;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+OpticalFlowImageFormatPropertiesNV& OpticalFlowImageFormatPropertiesNV::operator=(
+    const OpticalFlowImageFormatPropertiesNV& 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;
+}
+
+OpticalFlowImageFormatPropertiesNV::~OpticalFlowImageFormatPropertiesNV() { FreePnextChain(pNext); }
+
+void OpticalFlowImageFormatPropertiesNV::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 OpticalFlowImageFormatPropertiesNV::initialize(const OpticalFlowImageFormatPropertiesNV* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    format = copy_src->format;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+OpticalFlowSessionCreateInfoNV::OpticalFlowSessionCreateInfoNV(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);
+    }
+}
+
+OpticalFlowSessionCreateInfoNV::OpticalFlowSessionCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV),
+      pNext(nullptr),
+      width(),
+      height(),
+      imageFormat(),
+      flowVectorFormat(),
+      costFormat(),
+      outputGridSize(),
+      hintGridSize(),
+      performanceLevel(),
+      flags() {}
+
+OpticalFlowSessionCreateInfoNV::OpticalFlowSessionCreateInfoNV(const OpticalFlowSessionCreateInfoNV& 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);
+}
+
+OpticalFlowSessionCreateInfoNV& OpticalFlowSessionCreateInfoNV::operator=(const OpticalFlowSessionCreateInfoNV& 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;
+}
+
+OpticalFlowSessionCreateInfoNV::~OpticalFlowSessionCreateInfoNV() { FreePnextChain(pNext); }
+
+void OpticalFlowSessionCreateInfoNV::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 OpticalFlowSessionCreateInfoNV::initialize(const OpticalFlowSessionCreateInfoNV* 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);
+}
+
+OpticalFlowSessionCreatePrivateDataInfoNV::OpticalFlowSessionCreatePrivateDataInfoNV(
+    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);
+    }
+}
+
+OpticalFlowSessionCreatePrivateDataInfoNV::OpticalFlowSessionCreatePrivateDataInfoNV()
+    : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV),
+      pNext(nullptr),
+      id(),
+      size(),
+      pPrivateData(nullptr) {}
+
+OpticalFlowSessionCreatePrivateDataInfoNV::OpticalFlowSessionCreatePrivateDataInfoNV(
+    const OpticalFlowSessionCreatePrivateDataInfoNV& copy_src) {
+    sType = copy_src.sType;
+    id = copy_src.id;
+    size = copy_src.size;
+    pPrivateData = copy_src.pPrivateData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+OpticalFlowSessionCreatePrivateDataInfoNV& OpticalFlowSessionCreatePrivateDataInfoNV::operator=(
+    const OpticalFlowSessionCreatePrivateDataInfoNV& 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;
+}
+
+OpticalFlowSessionCreatePrivateDataInfoNV::~OpticalFlowSessionCreatePrivateDataInfoNV() { FreePnextChain(pNext); }
+
+void OpticalFlowSessionCreatePrivateDataInfoNV::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 OpticalFlowSessionCreatePrivateDataInfoNV::initialize(const OpticalFlowSessionCreatePrivateDataInfoNV* 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);
+}
+
+OpticalFlowExecuteInfoNV::OpticalFlowExecuteInfoNV(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);
+    }
+}
+
+OpticalFlowExecuteInfoNV::OpticalFlowExecuteInfoNV()
+    : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV), pNext(nullptr), flags(), regionCount(), pRegions(nullptr) {}
+
+OpticalFlowExecuteInfoNV::OpticalFlowExecuteInfoNV(const OpticalFlowExecuteInfoNV& 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);
+    }
+}
+
+OpticalFlowExecuteInfoNV& OpticalFlowExecuteInfoNV::operator=(const OpticalFlowExecuteInfoNV& 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;
+}
+
+OpticalFlowExecuteInfoNV::~OpticalFlowExecuteInfoNV() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void OpticalFlowExecuteInfoNV::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 OpticalFlowExecuteInfoNV::initialize(const OpticalFlowExecuteInfoNV* 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
+
+PhysicalDeviceExternalFormatResolveFeaturesANDROID::PhysicalDeviceExternalFormatResolveFeaturesANDROID(
+    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);
+    }
+}
+
+PhysicalDeviceExternalFormatResolveFeaturesANDROID::PhysicalDeviceExternalFormatResolveFeaturesANDROID()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID), pNext(nullptr), externalFormatResolve() {}
+
+PhysicalDeviceExternalFormatResolveFeaturesANDROID::PhysicalDeviceExternalFormatResolveFeaturesANDROID(
+    const PhysicalDeviceExternalFormatResolveFeaturesANDROID& copy_src) {
+    sType = copy_src.sType;
+    externalFormatResolve = copy_src.externalFormatResolve;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExternalFormatResolveFeaturesANDROID& PhysicalDeviceExternalFormatResolveFeaturesANDROID::operator=(
+    const PhysicalDeviceExternalFormatResolveFeaturesANDROID& 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;
+}
+
+PhysicalDeviceExternalFormatResolveFeaturesANDROID::~PhysicalDeviceExternalFormatResolveFeaturesANDROID() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExternalFormatResolveFeaturesANDROID::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 PhysicalDeviceExternalFormatResolveFeaturesANDROID::initialize(
+    const PhysicalDeviceExternalFormatResolveFeaturesANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalFormatResolve = copy_src->externalFormatResolve;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceExternalFormatResolvePropertiesANDROID::PhysicalDeviceExternalFormatResolvePropertiesANDROID(
+    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);
+    }
+}
+
+PhysicalDeviceExternalFormatResolvePropertiesANDROID::PhysicalDeviceExternalFormatResolvePropertiesANDROID()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID),
+      pNext(nullptr),
+      nullColorAttachmentWithExternalFormatResolve(),
+      externalFormatResolveChromaOffsetX(),
+      externalFormatResolveChromaOffsetY() {}
+
+PhysicalDeviceExternalFormatResolvePropertiesANDROID::PhysicalDeviceExternalFormatResolvePropertiesANDROID(
+    const PhysicalDeviceExternalFormatResolvePropertiesANDROID& copy_src) {
+    sType = copy_src.sType;
+    nullColorAttachmentWithExternalFormatResolve = copy_src.nullColorAttachmentWithExternalFormatResolve;
+    externalFormatResolveChromaOffsetX = copy_src.externalFormatResolveChromaOffsetX;
+    externalFormatResolveChromaOffsetY = copy_src.externalFormatResolveChromaOffsetY;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExternalFormatResolvePropertiesANDROID& PhysicalDeviceExternalFormatResolvePropertiesANDROID::operator=(
+    const PhysicalDeviceExternalFormatResolvePropertiesANDROID& 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;
+}
+
+PhysicalDeviceExternalFormatResolvePropertiesANDROID::~PhysicalDeviceExternalFormatResolvePropertiesANDROID() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceExternalFormatResolvePropertiesANDROID::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 PhysicalDeviceExternalFormatResolvePropertiesANDROID::initialize(
+    const PhysicalDeviceExternalFormatResolvePropertiesANDROID* 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);
+}
+
+AndroidHardwareBufferFormatResolvePropertiesANDROID::AndroidHardwareBufferFormatResolvePropertiesANDROID(
+    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);
+    }
+}
+
+AndroidHardwareBufferFormatResolvePropertiesANDROID::AndroidHardwareBufferFormatResolvePropertiesANDROID()
+    : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID), pNext(nullptr), colorAttachmentFormat() {}
+
+AndroidHardwareBufferFormatResolvePropertiesANDROID::AndroidHardwareBufferFormatResolvePropertiesANDROID(
+    const AndroidHardwareBufferFormatResolvePropertiesANDROID& copy_src) {
+    sType = copy_src.sType;
+    colorAttachmentFormat = copy_src.colorAttachmentFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AndroidHardwareBufferFormatResolvePropertiesANDROID& AndroidHardwareBufferFormatResolvePropertiesANDROID::operator=(
+    const AndroidHardwareBufferFormatResolvePropertiesANDROID& 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;
+}
+
+AndroidHardwareBufferFormatResolvePropertiesANDROID::~AndroidHardwareBufferFormatResolvePropertiesANDROID() {
+    FreePnextChain(pNext);
+}
+
+void AndroidHardwareBufferFormatResolvePropertiesANDROID::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 AndroidHardwareBufferFormatResolvePropertiesANDROID::initialize(
+    const AndroidHardwareBufferFormatResolvePropertiesANDROID* 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
+
+PhysicalDeviceTilePropertiesFeaturesQCOM::PhysicalDeviceTilePropertiesFeaturesQCOM(
+    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);
+    }
+}
+
+PhysicalDeviceTilePropertiesFeaturesQCOM::PhysicalDeviceTilePropertiesFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM), pNext(nullptr), tileProperties() {}
+
+PhysicalDeviceTilePropertiesFeaturesQCOM::PhysicalDeviceTilePropertiesFeaturesQCOM(
+    const PhysicalDeviceTilePropertiesFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    tileProperties = copy_src.tileProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceTilePropertiesFeaturesQCOM& PhysicalDeviceTilePropertiesFeaturesQCOM::operator=(
+    const PhysicalDeviceTilePropertiesFeaturesQCOM& 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;
+}
+
+PhysicalDeviceTilePropertiesFeaturesQCOM::~PhysicalDeviceTilePropertiesFeaturesQCOM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceTilePropertiesFeaturesQCOM::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 PhysicalDeviceTilePropertiesFeaturesQCOM::initialize(const PhysicalDeviceTilePropertiesFeaturesQCOM* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tileProperties = copy_src->tileProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+TilePropertiesQCOM::TilePropertiesQCOM(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);
+    }
+}
+
+TilePropertiesQCOM::TilePropertiesQCOM()
+    : sType(VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM), pNext(nullptr), tileSize(), apronSize(), origin() {}
+
+TilePropertiesQCOM::TilePropertiesQCOM(const TilePropertiesQCOM& copy_src) {
+    sType = copy_src.sType;
+    tileSize = copy_src.tileSize;
+    apronSize = copy_src.apronSize;
+    origin = copy_src.origin;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+TilePropertiesQCOM& TilePropertiesQCOM::operator=(const TilePropertiesQCOM& 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;
+}
+
+TilePropertiesQCOM::~TilePropertiesQCOM() { FreePnextChain(pNext); }
+
+void TilePropertiesQCOM::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 TilePropertiesQCOM::initialize(const TilePropertiesQCOM* 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);
+}
+
+PhysicalDeviceAmigoProfilingFeaturesSEC::PhysicalDeviceAmigoProfilingFeaturesSEC(
+    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);
+    }
+}
+
+PhysicalDeviceAmigoProfilingFeaturesSEC::PhysicalDeviceAmigoProfilingFeaturesSEC()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC), pNext(nullptr), amigoProfiling() {}
+
+PhysicalDeviceAmigoProfilingFeaturesSEC::PhysicalDeviceAmigoProfilingFeaturesSEC(
+    const PhysicalDeviceAmigoProfilingFeaturesSEC& copy_src) {
+    sType = copy_src.sType;
+    amigoProfiling = copy_src.amigoProfiling;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceAmigoProfilingFeaturesSEC& PhysicalDeviceAmigoProfilingFeaturesSEC::operator=(
+    const PhysicalDeviceAmigoProfilingFeaturesSEC& 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;
+}
+
+PhysicalDeviceAmigoProfilingFeaturesSEC::~PhysicalDeviceAmigoProfilingFeaturesSEC() { FreePnextChain(pNext); }
+
+void PhysicalDeviceAmigoProfilingFeaturesSEC::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 PhysicalDeviceAmigoProfilingFeaturesSEC::initialize(const PhysicalDeviceAmigoProfilingFeaturesSEC* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    amigoProfiling = copy_src->amigoProfiling;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+AmigoProfilingSubmitInfoSEC::AmigoProfilingSubmitInfoSEC(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);
+    }
+}
+
+AmigoProfilingSubmitInfoSEC::AmigoProfilingSubmitInfoSEC()
+    : sType(VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC), pNext(nullptr), firstDrawTimestamp(), swapBufferTimestamp() {}
+
+AmigoProfilingSubmitInfoSEC::AmigoProfilingSubmitInfoSEC(const AmigoProfilingSubmitInfoSEC& copy_src) {
+    sType = copy_src.sType;
+    firstDrawTimestamp = copy_src.firstDrawTimestamp;
+    swapBufferTimestamp = copy_src.swapBufferTimestamp;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+AmigoProfilingSubmitInfoSEC& AmigoProfilingSubmitInfoSEC::operator=(const AmigoProfilingSubmitInfoSEC& 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;
+}
+
+AmigoProfilingSubmitInfoSEC::~AmigoProfilingSubmitInfoSEC() { FreePnextChain(pNext); }
+
+void AmigoProfilingSubmitInfoSEC::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 AmigoProfilingSubmitInfoSEC::initialize(const AmigoProfilingSubmitInfoSEC* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    firstDrawTimestamp = copy_src->firstDrawTimestamp;
+    swapBufferTimestamp = copy_src->swapBufferTimestamp;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    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);
+    }
+}
+
+PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM),
+      pNext(nullptr),
+      multiviewPerViewViewports() {}
+
+PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    const PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    multiviewPerViewViewports = copy_src.multiviewPerViewViewports;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::operator=(
+    const PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& 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;
+}
+
+PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::~PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::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 PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::initialize(
+    const PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    multiviewPerViewViewports = copy_src->multiviewPerViewViewports;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceRayTracingInvocationReorderPropertiesNV::PhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceRayTracingInvocationReorderPropertiesNV::PhysicalDeviceRayTracingInvocationReorderPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV),
+      pNext(nullptr),
+      rayTracingInvocationReorderReorderingHint() {}
+
+PhysicalDeviceRayTracingInvocationReorderPropertiesNV::PhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    const PhysicalDeviceRayTracingInvocationReorderPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    rayTracingInvocationReorderReorderingHint = copy_src.rayTracingInvocationReorderReorderingHint;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRayTracingInvocationReorderPropertiesNV& PhysicalDeviceRayTracingInvocationReorderPropertiesNV::operator=(
+    const PhysicalDeviceRayTracingInvocationReorderPropertiesNV& 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;
+}
+
+PhysicalDeviceRayTracingInvocationReorderPropertiesNV::~PhysicalDeviceRayTracingInvocationReorderPropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceRayTracingInvocationReorderPropertiesNV::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 PhysicalDeviceRayTracingInvocationReorderPropertiesNV::initialize(
+    const PhysicalDeviceRayTracingInvocationReorderPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingInvocationReorderReorderingHint = copy_src->rayTracingInvocationReorderReorderingHint;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceRayTracingInvocationReorderFeaturesNV::PhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceRayTracingInvocationReorderFeaturesNV::PhysicalDeviceRayTracingInvocationReorderFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV),
+      pNext(nullptr),
+      rayTracingInvocationReorder() {}
+
+PhysicalDeviceRayTracingInvocationReorderFeaturesNV::PhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    const PhysicalDeviceRayTracingInvocationReorderFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    rayTracingInvocationReorder = copy_src.rayTracingInvocationReorder;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRayTracingInvocationReorderFeaturesNV& PhysicalDeviceRayTracingInvocationReorderFeaturesNV::operator=(
+    const PhysicalDeviceRayTracingInvocationReorderFeaturesNV& 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;
+}
+
+PhysicalDeviceRayTracingInvocationReorderFeaturesNV::~PhysicalDeviceRayTracingInvocationReorderFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceRayTracingInvocationReorderFeaturesNV::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 PhysicalDeviceRayTracingInvocationReorderFeaturesNV::initialize(
+    const PhysicalDeviceRayTracingInvocationReorderFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingInvocationReorder = copy_src->rayTracingInvocationReorder;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV),
+      pNext(nullptr),
+      extendedSparseAddressSpace() {}
+
+PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(
+    const PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    extendedSparseAddressSpace = copy_src.extendedSparseAddressSpace;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::operator=(
+    const PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& 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;
+}
+
+PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::~PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::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 PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::initialize(
+    const PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    extendedSparseAddressSpace = copy_src->extendedSparseAddressSpace;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceExtendedSparseAddressSpacePropertiesNV::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV(
+    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);
+    }
+}
+
+PhysicalDeviceExtendedSparseAddressSpacePropertiesNV::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV),
+      pNext(nullptr),
+      extendedSparseAddressSpaceSize(),
+      extendedSparseImageUsageFlags(),
+      extendedSparseBufferUsageFlags() {}
+
+PhysicalDeviceExtendedSparseAddressSpacePropertiesNV::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV(
+    const PhysicalDeviceExtendedSparseAddressSpacePropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    extendedSparseAddressSpaceSize = copy_src.extendedSparseAddressSpaceSize;
+    extendedSparseImageUsageFlags = copy_src.extendedSparseImageUsageFlags;
+    extendedSparseBufferUsageFlags = copy_src.extendedSparseBufferUsageFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExtendedSparseAddressSpacePropertiesNV& PhysicalDeviceExtendedSparseAddressSpacePropertiesNV::operator=(
+    const PhysicalDeviceExtendedSparseAddressSpacePropertiesNV& 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;
+}
+
+PhysicalDeviceExtendedSparseAddressSpacePropertiesNV::~PhysicalDeviceExtendedSparseAddressSpacePropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceExtendedSparseAddressSpacePropertiesNV::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 PhysicalDeviceExtendedSparseAddressSpacePropertiesNV::initialize(
+    const PhysicalDeviceExtendedSparseAddressSpacePropertiesNV* 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);
+}
+
+PhysicalDeviceShaderCoreBuiltinsFeaturesARM::PhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    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);
+    }
+}
+
+PhysicalDeviceShaderCoreBuiltinsFeaturesARM::PhysicalDeviceShaderCoreBuiltinsFeaturesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM), pNext(nullptr), shaderCoreBuiltins() {}
+
+PhysicalDeviceShaderCoreBuiltinsFeaturesARM::PhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    const PhysicalDeviceShaderCoreBuiltinsFeaturesARM& copy_src) {
+    sType = copy_src.sType;
+    shaderCoreBuiltins = copy_src.shaderCoreBuiltins;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderCoreBuiltinsFeaturesARM& PhysicalDeviceShaderCoreBuiltinsFeaturesARM::operator=(
+    const PhysicalDeviceShaderCoreBuiltinsFeaturesARM& 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;
+}
+
+PhysicalDeviceShaderCoreBuiltinsFeaturesARM::~PhysicalDeviceShaderCoreBuiltinsFeaturesARM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderCoreBuiltinsFeaturesARM::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 PhysicalDeviceShaderCoreBuiltinsFeaturesARM::initialize(const PhysicalDeviceShaderCoreBuiltinsFeaturesARM* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderCoreBuiltins = copy_src->shaderCoreBuiltins;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderCoreBuiltinsPropertiesARM::PhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    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);
+    }
+}
+
+PhysicalDeviceShaderCoreBuiltinsPropertiesARM::PhysicalDeviceShaderCoreBuiltinsPropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM),
+      pNext(nullptr),
+      shaderCoreMask(),
+      shaderCoreCount(),
+      shaderWarpsPerCore() {}
+
+PhysicalDeviceShaderCoreBuiltinsPropertiesARM::PhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    const PhysicalDeviceShaderCoreBuiltinsPropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    shaderCoreMask = copy_src.shaderCoreMask;
+    shaderCoreCount = copy_src.shaderCoreCount;
+    shaderWarpsPerCore = copy_src.shaderWarpsPerCore;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderCoreBuiltinsPropertiesARM& PhysicalDeviceShaderCoreBuiltinsPropertiesARM::operator=(
+    const PhysicalDeviceShaderCoreBuiltinsPropertiesARM& 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;
+}
+
+PhysicalDeviceShaderCoreBuiltinsPropertiesARM::~PhysicalDeviceShaderCoreBuiltinsPropertiesARM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderCoreBuiltinsPropertiesARM::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 PhysicalDeviceShaderCoreBuiltinsPropertiesARM::initialize(const PhysicalDeviceShaderCoreBuiltinsPropertiesARM* 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);
+}
+
+LatencySleepModeInfoNV::LatencySleepModeInfoNV(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);
+    }
+}
+
+LatencySleepModeInfoNV::LatencySleepModeInfoNV()
+    : sType(VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV),
+      pNext(nullptr),
+      lowLatencyMode(),
+      lowLatencyBoost(),
+      minimumIntervalUs() {}
+
+LatencySleepModeInfoNV::LatencySleepModeInfoNV(const LatencySleepModeInfoNV& copy_src) {
+    sType = copy_src.sType;
+    lowLatencyMode = copy_src.lowLatencyMode;
+    lowLatencyBoost = copy_src.lowLatencyBoost;
+    minimumIntervalUs = copy_src.minimumIntervalUs;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+LatencySleepModeInfoNV& LatencySleepModeInfoNV::operator=(const LatencySleepModeInfoNV& 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;
+}
+
+LatencySleepModeInfoNV::~LatencySleepModeInfoNV() { FreePnextChain(pNext); }
+
+void LatencySleepModeInfoNV::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 LatencySleepModeInfoNV::initialize(const LatencySleepModeInfoNV* 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);
+}
+
+LatencySleepInfoNV::LatencySleepInfoNV(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);
+    }
+}
+
+LatencySleepInfoNV::LatencySleepInfoNV()
+    : sType(VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV), pNext(nullptr), signalSemaphore(), value() {}
+
+LatencySleepInfoNV::LatencySleepInfoNV(const LatencySleepInfoNV& copy_src) {
+    sType = copy_src.sType;
+    signalSemaphore = copy_src.signalSemaphore;
+    value = copy_src.value;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+LatencySleepInfoNV& LatencySleepInfoNV::operator=(const LatencySleepInfoNV& 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;
+}
+
+LatencySleepInfoNV::~LatencySleepInfoNV() { FreePnextChain(pNext); }
+
+void LatencySleepInfoNV::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 LatencySleepInfoNV::initialize(const LatencySleepInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    signalSemaphore = copy_src->signalSemaphore;
+    value = copy_src->value;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SetLatencyMarkerInfoNV::SetLatencyMarkerInfoNV(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);
+    }
+}
+
+SetLatencyMarkerInfoNV::SetLatencyMarkerInfoNV()
+    : sType(VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV), pNext(nullptr), presentID(), marker() {}
+
+SetLatencyMarkerInfoNV::SetLatencyMarkerInfoNV(const SetLatencyMarkerInfoNV& copy_src) {
+    sType = copy_src.sType;
+    presentID = copy_src.presentID;
+    marker = copy_src.marker;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SetLatencyMarkerInfoNV& SetLatencyMarkerInfoNV::operator=(const SetLatencyMarkerInfoNV& 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;
+}
+
+SetLatencyMarkerInfoNV::~SetLatencyMarkerInfoNV() { FreePnextChain(pNext); }
+
+void SetLatencyMarkerInfoNV::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 SetLatencyMarkerInfoNV::initialize(const SetLatencyMarkerInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentID = copy_src->presentID;
+    marker = copy_src->marker;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+LatencyTimingsFrameReportNV::LatencyTimingsFrameReportNV(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);
+    }
+}
+
+LatencyTimingsFrameReportNV::LatencyTimingsFrameReportNV()
+    : 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() {}
+
+LatencyTimingsFrameReportNV::LatencyTimingsFrameReportNV(const LatencyTimingsFrameReportNV& 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);
+}
+
+LatencyTimingsFrameReportNV& LatencyTimingsFrameReportNV::operator=(const LatencyTimingsFrameReportNV& 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;
+}
+
+LatencyTimingsFrameReportNV::~LatencyTimingsFrameReportNV() { FreePnextChain(pNext); }
+
+void LatencyTimingsFrameReportNV::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 LatencyTimingsFrameReportNV::initialize(const LatencyTimingsFrameReportNV* 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);
+}
+
+GetLatencyMarkerInfoNV::GetLatencyMarkerInfoNV(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 LatencyTimingsFrameReportNV[timingCount];
+        for (uint32_t i = 0; i < timingCount; ++i) {
+            pTimings[i].initialize(&in_struct->pTimings[i]);
+        }
+    }
+}
+
+GetLatencyMarkerInfoNV::GetLatencyMarkerInfoNV()
+    : sType(VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV), pNext(nullptr), timingCount(), pTimings(nullptr) {}
+
+GetLatencyMarkerInfoNV::GetLatencyMarkerInfoNV(const GetLatencyMarkerInfoNV& copy_src) {
+    sType = copy_src.sType;
+    timingCount = copy_src.timingCount;
+    pTimings = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (timingCount && copy_src.pTimings) {
+        pTimings = new LatencyTimingsFrameReportNV[timingCount];
+        for (uint32_t i = 0; i < timingCount; ++i) {
+            pTimings[i].initialize(&copy_src.pTimings[i]);
+        }
+    }
+}
+
+GetLatencyMarkerInfoNV& GetLatencyMarkerInfoNV::operator=(const GetLatencyMarkerInfoNV& 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 LatencyTimingsFrameReportNV[timingCount];
+        for (uint32_t i = 0; i < timingCount; ++i) {
+            pTimings[i].initialize(&copy_src.pTimings[i]);
+        }
+    }
+
+    return *this;
+}
+
+GetLatencyMarkerInfoNV::~GetLatencyMarkerInfoNV() {
+    if (pTimings) delete[] pTimings;
+    FreePnextChain(pNext);
+}
+
+void GetLatencyMarkerInfoNV::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 LatencyTimingsFrameReportNV[timingCount];
+        for (uint32_t i = 0; i < timingCount; ++i) {
+            pTimings[i].initialize(&in_struct->pTimings[i]);
+        }
+    }
+}
+
+void GetLatencyMarkerInfoNV::initialize(const GetLatencyMarkerInfoNV* 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 LatencyTimingsFrameReportNV[timingCount];
+        for (uint32_t i = 0; i < timingCount; ++i) {
+            pTimings[i].initialize(&copy_src->pTimings[i]);
+        }
+    }
+}
+
+LatencySubmissionPresentIdNV::LatencySubmissionPresentIdNV(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);
+    }
+}
+
+LatencySubmissionPresentIdNV::LatencySubmissionPresentIdNV()
+    : sType(VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV), pNext(nullptr), presentID() {}
+
+LatencySubmissionPresentIdNV::LatencySubmissionPresentIdNV(const LatencySubmissionPresentIdNV& copy_src) {
+    sType = copy_src.sType;
+    presentID = copy_src.presentID;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+LatencySubmissionPresentIdNV& LatencySubmissionPresentIdNV::operator=(const LatencySubmissionPresentIdNV& 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;
+}
+
+LatencySubmissionPresentIdNV::~LatencySubmissionPresentIdNV() { FreePnextChain(pNext); }
+
+void LatencySubmissionPresentIdNV::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 LatencySubmissionPresentIdNV::initialize(const LatencySubmissionPresentIdNV* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentID = copy_src->presentID;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SwapchainLatencyCreateInfoNV::SwapchainLatencyCreateInfoNV(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);
+    }
+}
+
+SwapchainLatencyCreateInfoNV::SwapchainLatencyCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV), pNext(nullptr), latencyModeEnable() {}
+
+SwapchainLatencyCreateInfoNV::SwapchainLatencyCreateInfoNV(const SwapchainLatencyCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    latencyModeEnable = copy_src.latencyModeEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SwapchainLatencyCreateInfoNV& SwapchainLatencyCreateInfoNV::operator=(const SwapchainLatencyCreateInfoNV& 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;
+}
+
+SwapchainLatencyCreateInfoNV::~SwapchainLatencyCreateInfoNV() { FreePnextChain(pNext); }
+
+void SwapchainLatencyCreateInfoNV::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 SwapchainLatencyCreateInfoNV::initialize(const SwapchainLatencyCreateInfoNV* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    latencyModeEnable = copy_src->latencyModeEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+OutOfBandQueueTypeInfoNV::OutOfBandQueueTypeInfoNV(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);
+    }
+}
+
+OutOfBandQueueTypeInfoNV::OutOfBandQueueTypeInfoNV()
+    : sType(VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV), pNext(nullptr), queueType() {}
+
+OutOfBandQueueTypeInfoNV::OutOfBandQueueTypeInfoNV(const OutOfBandQueueTypeInfoNV& copy_src) {
+    sType = copy_src.sType;
+    queueType = copy_src.queueType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+OutOfBandQueueTypeInfoNV& OutOfBandQueueTypeInfoNV::operator=(const OutOfBandQueueTypeInfoNV& 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;
+}
+
+OutOfBandQueueTypeInfoNV::~OutOfBandQueueTypeInfoNV() { FreePnextChain(pNext); }
+
+void OutOfBandQueueTypeInfoNV::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 OutOfBandQueueTypeInfoNV::initialize(const OutOfBandQueueTypeInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queueType = copy_src->queueType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+LatencySurfaceCapabilitiesNV::LatencySurfaceCapabilitiesNV(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);
+    }
+}
+
+LatencySurfaceCapabilitiesNV::LatencySurfaceCapabilitiesNV()
+    : sType(VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV), pNext(nullptr), presentModeCount(), pPresentModes(nullptr) {}
+
+LatencySurfaceCapabilitiesNV::LatencySurfaceCapabilitiesNV(const LatencySurfaceCapabilitiesNV& 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);
+    }
+}
+
+LatencySurfaceCapabilitiesNV& LatencySurfaceCapabilitiesNV::operator=(const LatencySurfaceCapabilitiesNV& 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;
+}
+
+LatencySurfaceCapabilitiesNV::~LatencySurfaceCapabilitiesNV() {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+}
+
+void LatencySurfaceCapabilitiesNV::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 LatencySurfaceCapabilitiesNV::initialize(const LatencySurfaceCapabilitiesNV* 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);
+    }
+}
+
+PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    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);
+    }
+}
+
+PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM),
+      pNext(nullptr),
+      multiviewPerViewRenderAreas() {}
+
+PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    const PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    multiviewPerViewRenderAreas = copy_src.multiviewPerViewRenderAreas;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::operator=(
+    const PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& 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;
+}
+
+PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::~PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::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 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::initialize(
+    const PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    multiviewPerViewRenderAreas = copy_src->multiviewPerViewRenderAreas;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    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);
+    }
+}
+
+MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM),
+      pNext(nullptr),
+      perViewRenderAreaCount(),
+      pPerViewRenderAreas(nullptr) {}
+
+MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    const MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& 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);
+    }
+}
+
+MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::operator=(
+    const MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& 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;
+}
+
+MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::~MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM() {
+    if (pPerViewRenderAreas) delete[] pPerViewRenderAreas;
+    FreePnextChain(pNext);
+}
+
+void MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::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 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::initialize(
+    const MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* 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);
+    }
+}
+
+PhysicalDevicePerStageDescriptorSetFeaturesNV::PhysicalDevicePerStageDescriptorSetFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDevicePerStageDescriptorSetFeaturesNV::PhysicalDevicePerStageDescriptorSetFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV),
+      pNext(nullptr),
+      perStageDescriptorSet(),
+      dynamicPipelineLayout() {}
+
+PhysicalDevicePerStageDescriptorSetFeaturesNV::PhysicalDevicePerStageDescriptorSetFeaturesNV(
+    const PhysicalDevicePerStageDescriptorSetFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    perStageDescriptorSet = copy_src.perStageDescriptorSet;
+    dynamicPipelineLayout = copy_src.dynamicPipelineLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDevicePerStageDescriptorSetFeaturesNV& PhysicalDevicePerStageDescriptorSetFeaturesNV::operator=(
+    const PhysicalDevicePerStageDescriptorSetFeaturesNV& 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;
+}
+
+PhysicalDevicePerStageDescriptorSetFeaturesNV::~PhysicalDevicePerStageDescriptorSetFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDevicePerStageDescriptorSetFeaturesNV::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 PhysicalDevicePerStageDescriptorSetFeaturesNV::initialize(const PhysicalDevicePerStageDescriptorSetFeaturesNV* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    perStageDescriptorSet = copy_src->perStageDescriptorSet;
+    dynamicPipelineLayout = copy_src->dynamicPipelineLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceImageProcessing2FeaturesQCOM::PhysicalDeviceImageProcessing2FeaturesQCOM(
+    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);
+    }
+}
+
+PhysicalDeviceImageProcessing2FeaturesQCOM::PhysicalDeviceImageProcessing2FeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM), pNext(nullptr), textureBlockMatch2() {}
+
+PhysicalDeviceImageProcessing2FeaturesQCOM::PhysicalDeviceImageProcessing2FeaturesQCOM(
+    const PhysicalDeviceImageProcessing2FeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    textureBlockMatch2 = copy_src.textureBlockMatch2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceImageProcessing2FeaturesQCOM& PhysicalDeviceImageProcessing2FeaturesQCOM::operator=(
+    const PhysicalDeviceImageProcessing2FeaturesQCOM& 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;
+}
+
+PhysicalDeviceImageProcessing2FeaturesQCOM::~PhysicalDeviceImageProcessing2FeaturesQCOM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImageProcessing2FeaturesQCOM::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 PhysicalDeviceImageProcessing2FeaturesQCOM::initialize(const PhysicalDeviceImageProcessing2FeaturesQCOM* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    textureBlockMatch2 = copy_src->textureBlockMatch2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceImageProcessing2PropertiesQCOM::PhysicalDeviceImageProcessing2PropertiesQCOM(
+    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);
+    }
+}
+
+PhysicalDeviceImageProcessing2PropertiesQCOM::PhysicalDeviceImageProcessing2PropertiesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM), pNext(nullptr), maxBlockMatchWindow() {}
+
+PhysicalDeviceImageProcessing2PropertiesQCOM::PhysicalDeviceImageProcessing2PropertiesQCOM(
+    const PhysicalDeviceImageProcessing2PropertiesQCOM& copy_src) {
+    sType = copy_src.sType;
+    maxBlockMatchWindow = copy_src.maxBlockMatchWindow;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceImageProcessing2PropertiesQCOM& PhysicalDeviceImageProcessing2PropertiesQCOM::operator=(
+    const PhysicalDeviceImageProcessing2PropertiesQCOM& 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;
+}
+
+PhysicalDeviceImageProcessing2PropertiesQCOM::~PhysicalDeviceImageProcessing2PropertiesQCOM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceImageProcessing2PropertiesQCOM::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 PhysicalDeviceImageProcessing2PropertiesQCOM::initialize(const PhysicalDeviceImageProcessing2PropertiesQCOM* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxBlockMatchWindow = copy_src->maxBlockMatchWindow;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SamplerBlockMatchWindowCreateInfoQCOM::SamplerBlockMatchWindowCreateInfoQCOM(
+    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);
+    }
+}
+
+SamplerBlockMatchWindowCreateInfoQCOM::SamplerBlockMatchWindowCreateInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM), pNext(nullptr), windowExtent(), windowCompareMode() {}
+
+SamplerBlockMatchWindowCreateInfoQCOM::SamplerBlockMatchWindowCreateInfoQCOM(
+    const SamplerBlockMatchWindowCreateInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    windowExtent = copy_src.windowExtent;
+    windowCompareMode = copy_src.windowCompareMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SamplerBlockMatchWindowCreateInfoQCOM& SamplerBlockMatchWindowCreateInfoQCOM::operator=(
+    const SamplerBlockMatchWindowCreateInfoQCOM& 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;
+}
+
+SamplerBlockMatchWindowCreateInfoQCOM::~SamplerBlockMatchWindowCreateInfoQCOM() { FreePnextChain(pNext); }
+
+void SamplerBlockMatchWindowCreateInfoQCOM::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 SamplerBlockMatchWindowCreateInfoQCOM::initialize(const SamplerBlockMatchWindowCreateInfoQCOM* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    windowExtent = copy_src->windowExtent;
+    windowCompareMode = copy_src->windowCompareMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceCubicWeightsFeaturesQCOM::PhysicalDeviceCubicWeightsFeaturesQCOM(
+    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);
+    }
+}
+
+PhysicalDeviceCubicWeightsFeaturesQCOM::PhysicalDeviceCubicWeightsFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM), pNext(nullptr), selectableCubicWeights() {}
+
+PhysicalDeviceCubicWeightsFeaturesQCOM::PhysicalDeviceCubicWeightsFeaturesQCOM(
+    const PhysicalDeviceCubicWeightsFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    selectableCubicWeights = copy_src.selectableCubicWeights;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCubicWeightsFeaturesQCOM& PhysicalDeviceCubicWeightsFeaturesQCOM::operator=(
+    const PhysicalDeviceCubicWeightsFeaturesQCOM& 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;
+}
+
+PhysicalDeviceCubicWeightsFeaturesQCOM::~PhysicalDeviceCubicWeightsFeaturesQCOM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCubicWeightsFeaturesQCOM::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 PhysicalDeviceCubicWeightsFeaturesQCOM::initialize(const PhysicalDeviceCubicWeightsFeaturesQCOM* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    selectableCubicWeights = copy_src->selectableCubicWeights;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SamplerCubicWeightsCreateInfoQCOM::SamplerCubicWeightsCreateInfoQCOM(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);
+    }
+}
+
+SamplerCubicWeightsCreateInfoQCOM::SamplerCubicWeightsCreateInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM), pNext(nullptr), cubicWeights() {}
+
+SamplerCubicWeightsCreateInfoQCOM::SamplerCubicWeightsCreateInfoQCOM(const SamplerCubicWeightsCreateInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    cubicWeights = copy_src.cubicWeights;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SamplerCubicWeightsCreateInfoQCOM& SamplerCubicWeightsCreateInfoQCOM::operator=(const SamplerCubicWeightsCreateInfoQCOM& 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;
+}
+
+SamplerCubicWeightsCreateInfoQCOM::~SamplerCubicWeightsCreateInfoQCOM() { FreePnextChain(pNext); }
+
+void SamplerCubicWeightsCreateInfoQCOM::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 SamplerCubicWeightsCreateInfoQCOM::initialize(const SamplerCubicWeightsCreateInfoQCOM* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cubicWeights = copy_src->cubicWeights;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+BlitImageCubicWeightsInfoQCOM::BlitImageCubicWeightsInfoQCOM(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);
+    }
+}
+
+BlitImageCubicWeightsInfoQCOM::BlitImageCubicWeightsInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM), pNext(nullptr), cubicWeights() {}
+
+BlitImageCubicWeightsInfoQCOM::BlitImageCubicWeightsInfoQCOM(const BlitImageCubicWeightsInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    cubicWeights = copy_src.cubicWeights;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+BlitImageCubicWeightsInfoQCOM& BlitImageCubicWeightsInfoQCOM::operator=(const BlitImageCubicWeightsInfoQCOM& 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;
+}
+
+BlitImageCubicWeightsInfoQCOM::~BlitImageCubicWeightsInfoQCOM() { FreePnextChain(pNext); }
+
+void BlitImageCubicWeightsInfoQCOM::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 BlitImageCubicWeightsInfoQCOM::initialize(const BlitImageCubicWeightsInfoQCOM* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cubicWeights = copy_src->cubicWeights;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceYcbcrDegammaFeaturesQCOM::PhysicalDeviceYcbcrDegammaFeaturesQCOM(
+    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);
+    }
+}
+
+PhysicalDeviceYcbcrDegammaFeaturesQCOM::PhysicalDeviceYcbcrDegammaFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM), pNext(nullptr), ycbcrDegamma() {}
+
+PhysicalDeviceYcbcrDegammaFeaturesQCOM::PhysicalDeviceYcbcrDegammaFeaturesQCOM(
+    const PhysicalDeviceYcbcrDegammaFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    ycbcrDegamma = copy_src.ycbcrDegamma;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceYcbcrDegammaFeaturesQCOM& PhysicalDeviceYcbcrDegammaFeaturesQCOM::operator=(
+    const PhysicalDeviceYcbcrDegammaFeaturesQCOM& 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;
+}
+
+PhysicalDeviceYcbcrDegammaFeaturesQCOM::~PhysicalDeviceYcbcrDegammaFeaturesQCOM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceYcbcrDegammaFeaturesQCOM::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 PhysicalDeviceYcbcrDegammaFeaturesQCOM::initialize(const PhysicalDeviceYcbcrDegammaFeaturesQCOM* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    ycbcrDegamma = copy_src->ycbcrDegamma;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(
+    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);
+    }
+}
+
+SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM),
+      pNext(nullptr),
+      enableYDegamma(),
+      enableCbCrDegamma() {}
+
+SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(
+    const SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    enableYDegamma = copy_src.enableYDegamma;
+    enableCbCrDegamma = copy_src.enableCbCrDegamma;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::operator=(
+    const SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& 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;
+}
+
+SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::~SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM() { FreePnextChain(pNext); }
+
+void SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::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 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::initialize(const SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    enableYDegamma = copy_src->enableYDegamma;
+    enableCbCrDegamma = copy_src->enableCbCrDegamma;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceCubicClampFeaturesQCOM::PhysicalDeviceCubicClampFeaturesQCOM(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);
+    }
+}
+
+PhysicalDeviceCubicClampFeaturesQCOM::PhysicalDeviceCubicClampFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM), pNext(nullptr), cubicRangeClamp() {}
+
+PhysicalDeviceCubicClampFeaturesQCOM::PhysicalDeviceCubicClampFeaturesQCOM(const PhysicalDeviceCubicClampFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    cubicRangeClamp = copy_src.cubicRangeClamp;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceCubicClampFeaturesQCOM& PhysicalDeviceCubicClampFeaturesQCOM::operator=(
+    const PhysicalDeviceCubicClampFeaturesQCOM& 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;
+}
+
+PhysicalDeviceCubicClampFeaturesQCOM::~PhysicalDeviceCubicClampFeaturesQCOM() { FreePnextChain(pNext); }
+
+void PhysicalDeviceCubicClampFeaturesQCOM::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 PhysicalDeviceCubicClampFeaturesQCOM::initialize(const PhysicalDeviceCubicClampFeaturesQCOM* 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
+
+ScreenBufferPropertiesQNX::ScreenBufferPropertiesQNX(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);
+    }
+}
+
+ScreenBufferPropertiesQNX::ScreenBufferPropertiesQNX()
+    : sType(VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX), pNext(nullptr), allocationSize(), memoryTypeBits() {}
+
+ScreenBufferPropertiesQNX::ScreenBufferPropertiesQNX(const ScreenBufferPropertiesQNX& copy_src) {
+    sType = copy_src.sType;
+    allocationSize = copy_src.allocationSize;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ScreenBufferPropertiesQNX& ScreenBufferPropertiesQNX::operator=(const ScreenBufferPropertiesQNX& 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;
+}
+
+ScreenBufferPropertiesQNX::~ScreenBufferPropertiesQNX() { FreePnextChain(pNext); }
+
+void ScreenBufferPropertiesQNX::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 ScreenBufferPropertiesQNX::initialize(const ScreenBufferPropertiesQNX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    allocationSize = copy_src->allocationSize;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+ScreenBufferFormatPropertiesQNX::ScreenBufferFormatPropertiesQNX(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);
+    }
+}
+
+ScreenBufferFormatPropertiesQNX::ScreenBufferFormatPropertiesQNX()
+    : sType(VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX),
+      pNext(nullptr),
+      format(),
+      externalFormat(),
+      screenUsage(),
+      formatFeatures(),
+      samplerYcbcrConversionComponents(),
+      suggestedYcbcrModel(),
+      suggestedYcbcrRange(),
+      suggestedXChromaOffset(),
+      suggestedYChromaOffset() {}
+
+ScreenBufferFormatPropertiesQNX::ScreenBufferFormatPropertiesQNX(const ScreenBufferFormatPropertiesQNX& 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);
+}
+
+ScreenBufferFormatPropertiesQNX& ScreenBufferFormatPropertiesQNX::operator=(const ScreenBufferFormatPropertiesQNX& 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;
+}
+
+ScreenBufferFormatPropertiesQNX::~ScreenBufferFormatPropertiesQNX() { FreePnextChain(pNext); }
+
+void ScreenBufferFormatPropertiesQNX::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 ScreenBufferFormatPropertiesQNX::initialize(const ScreenBufferFormatPropertiesQNX* 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);
+}
+
+ImportScreenBufferInfoQNX::ImportScreenBufferInfoQNX(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);
+    }
+}
+
+ImportScreenBufferInfoQNX::ImportScreenBufferInfoQNX()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX), pNext(nullptr), buffer(nullptr) {}
+
+ImportScreenBufferInfoQNX::ImportScreenBufferInfoQNX(const ImportScreenBufferInfoQNX& copy_src) {
+    sType = copy_src.sType;
+    buffer = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.buffer) {
+        buffer = new _screen_buffer(*copy_src.buffer);
+    }
+}
+
+ImportScreenBufferInfoQNX& ImportScreenBufferInfoQNX::operator=(const ImportScreenBufferInfoQNX& 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;
+}
+
+ImportScreenBufferInfoQNX::~ImportScreenBufferInfoQNX() {
+    if (buffer) delete buffer;
+    FreePnextChain(pNext);
+}
+
+void ImportScreenBufferInfoQNX::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 ImportScreenBufferInfoQNX::initialize(const ImportScreenBufferInfoQNX* 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);
+    }
+}
+
+ExternalFormatQNX::ExternalFormatQNX(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);
+    }
+}
+
+ExternalFormatQNX::ExternalFormatQNX() : sType(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX), pNext(nullptr), externalFormat() {}
+
+ExternalFormatQNX::ExternalFormatQNX(const ExternalFormatQNX& copy_src) {
+    sType = copy_src.sType;
+    externalFormat = copy_src.externalFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+ExternalFormatQNX& ExternalFormatQNX::operator=(const ExternalFormatQNX& 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;
+}
+
+ExternalFormatQNX::~ExternalFormatQNX() { FreePnextChain(pNext); }
+
+void ExternalFormatQNX::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 ExternalFormatQNX::initialize(const ExternalFormatQNX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalFormat = copy_src->externalFormat;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(
+    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);
+    }
+}
+
+PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX), pNext(nullptr), screenBufferImport() {}
+
+PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(
+    const PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& copy_src) {
+    sType = copy_src.sType;
+    screenBufferImport = copy_src.screenBufferImport;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::operator=(
+    const PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& 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;
+}
+
+PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::~PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::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 PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::initialize(
+    const PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* 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
+
+PhysicalDeviceLayeredDriverPropertiesMSFT::PhysicalDeviceLayeredDriverPropertiesMSFT(
+    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);
+    }
+}
+
+PhysicalDeviceLayeredDriverPropertiesMSFT::PhysicalDeviceLayeredDriverPropertiesMSFT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT), pNext(nullptr), underlyingAPI() {}
+
+PhysicalDeviceLayeredDriverPropertiesMSFT::PhysicalDeviceLayeredDriverPropertiesMSFT(
+    const PhysicalDeviceLayeredDriverPropertiesMSFT& copy_src) {
+    sType = copy_src.sType;
+    underlyingAPI = copy_src.underlyingAPI;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceLayeredDriverPropertiesMSFT& PhysicalDeviceLayeredDriverPropertiesMSFT::operator=(
+    const PhysicalDeviceLayeredDriverPropertiesMSFT& 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;
+}
+
+PhysicalDeviceLayeredDriverPropertiesMSFT::~PhysicalDeviceLayeredDriverPropertiesMSFT() { FreePnextChain(pNext); }
+
+void PhysicalDeviceLayeredDriverPropertiesMSFT::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 PhysicalDeviceLayeredDriverPropertiesMSFT::initialize(const PhysicalDeviceLayeredDriverPropertiesMSFT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    underlyingAPI = copy_src->underlyingAPI;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceDescriptorPoolOverallocationFeaturesNV::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceDescriptorPoolOverallocationFeaturesNV::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV),
+      pNext(nullptr),
+      descriptorPoolOverallocation() {}
+
+PhysicalDeviceDescriptorPoolOverallocationFeaturesNV::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV(
+    const PhysicalDeviceDescriptorPoolOverallocationFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    descriptorPoolOverallocation = copy_src.descriptorPoolOverallocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceDescriptorPoolOverallocationFeaturesNV& PhysicalDeviceDescriptorPoolOverallocationFeaturesNV::operator=(
+    const PhysicalDeviceDescriptorPoolOverallocationFeaturesNV& 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;
+}
+
+PhysicalDeviceDescriptorPoolOverallocationFeaturesNV::~PhysicalDeviceDescriptorPoolOverallocationFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void PhysicalDeviceDescriptorPoolOverallocationFeaturesNV::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 PhysicalDeviceDescriptorPoolOverallocationFeaturesNV::initialize(
+    const PhysicalDeviceDescriptorPoolOverallocationFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorPoolOverallocation = copy_src->descriptorPoolOverallocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceRawAccessChainsFeaturesNV::PhysicalDeviceRawAccessChainsFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceRawAccessChainsFeaturesNV::PhysicalDeviceRawAccessChainsFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV), pNext(nullptr), shaderRawAccessChains() {}
+
+PhysicalDeviceRawAccessChainsFeaturesNV::PhysicalDeviceRawAccessChainsFeaturesNV(
+    const PhysicalDeviceRawAccessChainsFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    shaderRawAccessChains = copy_src.shaderRawAccessChains;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRawAccessChainsFeaturesNV& PhysicalDeviceRawAccessChainsFeaturesNV::operator=(
+    const PhysicalDeviceRawAccessChainsFeaturesNV& 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;
+}
+
+PhysicalDeviceRawAccessChainsFeaturesNV::~PhysicalDeviceRawAccessChainsFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRawAccessChainsFeaturesNV::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 PhysicalDeviceRawAccessChainsFeaturesNV::initialize(const PhysicalDeviceRawAccessChainsFeaturesNV* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderRawAccessChains = copy_src->shaderRawAccessChains;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV),
+      pNext(nullptr),
+      shaderFloat16VectorAtomics() {}
+
+PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(
+    const PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    shaderFloat16VectorAtomics = copy_src.shaderFloat16VectorAtomics;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::operator=(
+    const PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& 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;
+}
+
+PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::~PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::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 PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::initialize(
+    const PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderFloat16VectorAtomics = copy_src->shaderFloat16VectorAtomics;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+PhysicalDeviceRayTracingValidationFeaturesNV::PhysicalDeviceRayTracingValidationFeaturesNV(
+    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);
+    }
+}
+
+PhysicalDeviceRayTracingValidationFeaturesNV::PhysicalDeviceRayTracingValidationFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV), pNext(nullptr), rayTracingValidation() {}
+
+PhysicalDeviceRayTracingValidationFeaturesNV::PhysicalDeviceRayTracingValidationFeaturesNV(
+    const PhysicalDeviceRayTracingValidationFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    rayTracingValidation = copy_src.rayTracingValidation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+PhysicalDeviceRayTracingValidationFeaturesNV& PhysicalDeviceRayTracingValidationFeaturesNV::operator=(
+    const PhysicalDeviceRayTracingValidationFeaturesNV& 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;
+}
+
+PhysicalDeviceRayTracingValidationFeaturesNV::~PhysicalDeviceRayTracingValidationFeaturesNV() { FreePnextChain(pNext); }
+
+void PhysicalDeviceRayTracingValidationFeaturesNV::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 PhysicalDeviceRayTracingValidationFeaturesNV::initialize(const PhysicalDeviceRayTracingValidationFeaturesNV* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingValidation = copy_src->rayTracingValidation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+}  // namespace safe
+}  // 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..afb9c08
--- /dev/null
+++ b/tests/safe_struct.cpp
@@ -0,0 +1,157 @@
+// 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>
+
+TEST(safe_struct, basic) {
+    vku::safe::InstanceCreateInfo 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::SpecializationInfo, constructor
+    {
+        std::vector<std::byte> data(20, std::byte{0b11110000});
+
+        VkSpecializationInfo info = {};
+        info.dataSize = uint32_t(data.size());
+        info.pData = data.data();
+
+        vku::safe::SpecializationInfo 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::PipelineExecutableInternalRepresentationKHR, initialize
+    {
+        std::vector<std::byte> data(11, std::byte{0b01001001});
+
+        VkPipelineExecutableInternalRepresentationKHR info = {};
+        info.dataSize = uint32_t(data.size());
+        info.pData = data.data();
+
+        vku::safe::PipelineExecutableInternalRepresentationKHR 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::safe::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::PipelineRenderingCreateInfo *>(safe_struct);
+                tmp->colorAttachmentCount = 0;
+                tmp->pColorAttachmentFormats = nullptr;
+                return true;
+            }
+            return false;
+        },
+    };
+
+    {
+        VkGraphicsPipelineCreateInfo gpci = vku::InitStructHelper(&pri);
+        vku::safe::GraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, &copy_state);
+
+        auto safe_pri = reinterpret_cast<const vku::safe::PipelineRenderingCreateInfo *>(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::GraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, &copy_state);
+
+        auto safe_gpl_info = reinterpret_cast<const vku::safe::GraphicsPipelineLibraryCreateInfoEXT *>(safe_gpci.pNext);
+        auto safe_pri = reinterpret_cast<const vku::safe::PipelineRenderingCreateInfo *>(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::GraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, &copy_state);
+
+        auto safe_pri = reinterpret_cast<const vku::safe::PipelineRenderingCreateInfo *>(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);
+    }
+}