chromium/third_party/vulkan-utility-libraries/src/src/vulkan/vk_safe_struct_khr.cpp

// *** THIS FILE IS GENERATED - DO NOT EDIT ***
// See safe_struct_generator.py for modifications

/***************************************************************************
 *
 * Copyright (c) 2015-2024 The Khronos Group Inc.
 * Copyright (c) 2015-2024 Valve Corporation
 * Copyright (c) 2015-2024 LunarG, Inc.
 * Copyright (c) 2015-2024 Google Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 ****************************************************************************/

// NOLINTBEGIN

#include <vulkan/utility/vk_safe_struct.hpp>
#include <vulkan/utility/vk_struct_helper.hpp>

#include <cstring>

namespace vku {

safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct,
                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR()
    : … { … }

safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& copy_src) { … }

safe_VkSwapchainCreateInfoKHR& safe_VkSwapchainCreateInfoKHR::operator=(const safe_VkSwapchainCreateInfoKHR& copy_src) { … }

safe_VkSwapchainCreateInfoKHR::~safe_VkSwapchainCreateInfoKHR() { … }

void safe_VkSwapchainCreateInfoKHR::initialize(const VkSwapchainCreateInfoKHR* in_struct,
                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkSwapchainCreateInfoKHR::initialize(const safe_VkSwapchainCreateInfoKHR* copy_src,
                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
                                             bool copy_pnext)
    : … { … }

safe_VkPresentInfoKHR::safe_VkPresentInfoKHR()
    : … { … }

safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& copy_src) { … }

safe_VkPresentInfoKHR& safe_VkPresentInfoKHR::operator=(const safe_VkPresentInfoKHR& copy_src) { … }

safe_VkPresentInfoKHR::~safe_VkPresentInfoKHR() { … }

void safe_VkPresentInfoKHR::initialize(const VkPresentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPresentInfoKHR::initialize(const safe_VkPresentInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct,
                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR()
    : … { … }

safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR(const safe_VkImageSwapchainCreateInfoKHR& copy_src) { … }

safe_VkImageSwapchainCreateInfoKHR& safe_VkImageSwapchainCreateInfoKHR::operator=(
    const safe_VkImageSwapchainCreateInfoKHR& copy_src) { … }

safe_VkImageSwapchainCreateInfoKHR::~safe_VkImageSwapchainCreateInfoKHR() { … }

void safe_VkImageSwapchainCreateInfoKHR::initialize(const VkImageSwapchainCreateInfoKHR* in_struct,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkImageSwapchainCreateInfoKHR::initialize(const safe_VkImageSwapchainCreateInfoKHR* copy_src,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct,
                                                                               [[maybe_unused]] PNextCopyState* copy_state,
                                                                               bool copy_pnext)
    : … { … }

safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR()
    : … { … }

safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR(
    const safe_VkBindImageMemorySwapchainInfoKHR& copy_src) { … }

safe_VkBindImageMemorySwapchainInfoKHR& safe_VkBindImageMemorySwapchainInfoKHR::operator=(
    const safe_VkBindImageMemorySwapchainInfoKHR& copy_src) { … }

safe_VkBindImageMemorySwapchainInfoKHR::~safe_VkBindImageMemorySwapchainInfoKHR() { … }

void safe_VkBindImageMemorySwapchainInfoKHR::initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct,
                                                        [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkBindImageMemorySwapchainInfoKHR::initialize(const safe_VkBindImageMemorySwapchainInfoKHR* copy_src,
                                                        [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR()
    : … { … }

safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR(const safe_VkAcquireNextImageInfoKHR& copy_src) { … }

safe_VkAcquireNextImageInfoKHR& safe_VkAcquireNextImageInfoKHR::operator=(const safe_VkAcquireNextImageInfoKHR& copy_src) { … }

safe_VkAcquireNextImageInfoKHR::~safe_VkAcquireNextImageInfoKHR() { … }

void safe_VkAcquireNextImageInfoKHR::initialize(const VkAcquireNextImageInfoKHR* in_struct,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkAcquireNextImageInfoKHR::initialize(const safe_VkAcquireNextImageInfoKHR* copy_src,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR(
    const VkDeviceGroupPresentCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR()
    : … { … }

safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR(
    const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src) { … }

safe_VkDeviceGroupPresentCapabilitiesKHR& safe_VkDeviceGroupPresentCapabilitiesKHR::operator=(
    const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src) { … }

safe_VkDeviceGroupPresentCapabilitiesKHR::~safe_VkDeviceGroupPresentCapabilitiesKHR() { … }

void safe_VkDeviceGroupPresentCapabilitiesKHR::initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDeviceGroupPresentCapabilitiesKHR::initialize(const safe_VkDeviceGroupPresentCapabilitiesKHR* copy_src,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR()
    : … { … }

safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR(const safe_VkDeviceGroupPresentInfoKHR& copy_src) { … }

safe_VkDeviceGroupPresentInfoKHR& safe_VkDeviceGroupPresentInfoKHR::operator=(const safe_VkDeviceGroupPresentInfoKHR& copy_src) { … }

safe_VkDeviceGroupPresentInfoKHR::~safe_VkDeviceGroupPresentInfoKHR() { … }

void safe_VkDeviceGroupPresentInfoKHR::initialize(const VkDeviceGroupPresentInfoKHR* in_struct,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDeviceGroupPresentInfoKHR::initialize(const safe_VkDeviceGroupPresentInfoKHR* copy_src,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR(
    const VkDeviceGroupSwapchainCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR()
    : … { … }

safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR(
    const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src) { … }

safe_VkDeviceGroupSwapchainCreateInfoKHR& safe_VkDeviceGroupSwapchainCreateInfoKHR::operator=(
    const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src) { … }

safe_VkDeviceGroupSwapchainCreateInfoKHR::~safe_VkDeviceGroupSwapchainCreateInfoKHR() { … }

void safe_VkDeviceGroupSwapchainCreateInfoKHR::initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDeviceGroupSwapchainCreateInfoKHR::initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHR* copy_src,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct,
                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR()
    : … { … }

safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& copy_src) { … }

safe_VkDisplayModeCreateInfoKHR& safe_VkDisplayModeCreateInfoKHR::operator=(const safe_VkDisplayModeCreateInfoKHR& copy_src) { … }

safe_VkDisplayModeCreateInfoKHR::~safe_VkDisplayModeCreateInfoKHR() { … }

void safe_VkDisplayModeCreateInfoKHR::initialize(const VkDisplayModeCreateInfoKHR* in_struct,
                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDisplayModeCreateInfoKHR::initialize(const safe_VkDisplayModeCreateInfoKHR* copy_src,
                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct,
                                                         [[maybe_unused]] PNextCopyState* copy_state)
    : … { … }

safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR()
    : … { … }

safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& copy_src) { … }

safe_VkDisplayPropertiesKHR& safe_VkDisplayPropertiesKHR::operator=(const safe_VkDisplayPropertiesKHR& copy_src) { … }

safe_VkDisplayPropertiesKHR::~safe_VkDisplayPropertiesKHR() { … }

void safe_VkDisplayPropertiesKHR::initialize(const VkDisplayPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDisplayPropertiesKHR::initialize(const safe_VkDisplayPropertiesKHR* copy_src,
                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct,
                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR()
    : … { … }

safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src) { … }

safe_VkDisplaySurfaceCreateInfoKHR& safe_VkDisplaySurfaceCreateInfoKHR::operator=(
    const safe_VkDisplaySurfaceCreateInfoKHR& copy_src) { … }

safe_VkDisplaySurfaceCreateInfoKHR::~safe_VkDisplaySurfaceCreateInfoKHR() { … }

void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const safe_VkDisplaySurfaceCreateInfoKHR* copy_src,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR()
    : … { … }

safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& copy_src) { … }

safe_VkDisplayPresentInfoKHR& safe_VkDisplayPresentInfoKHR::operator=(const safe_VkDisplayPresentInfoKHR& copy_src) { … }

safe_VkDisplayPresentInfoKHR::~safe_VkDisplayPresentInfoKHR() { … }

void safe_VkDisplayPresentInfoKHR::initialize(const VkDisplayPresentInfoKHR* in_struct,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDisplayPresentInfoKHR::initialize(const safe_VkDisplayPresentInfoKHR* copy_src,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkQueueFamilyQueryResultStatusPropertiesKHR::safe_VkQueueFamilyQueryResultStatusPropertiesKHR(
    const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkQueueFamilyQueryResultStatusPropertiesKHR::safe_VkQueueFamilyQueryResultStatusPropertiesKHR()
    : … { … }

safe_VkQueueFamilyQueryResultStatusPropertiesKHR::safe_VkQueueFamilyQueryResultStatusPropertiesKHR(
    const safe_VkQueueFamilyQueryResultStatusPropertiesKHR& copy_src) { … }

safe_VkQueueFamilyQueryResultStatusPropertiesKHR& safe_VkQueueFamilyQueryResultStatusPropertiesKHR::operator=(
    const safe_VkQueueFamilyQueryResultStatusPropertiesKHR& copy_src) { … }

safe_VkQueueFamilyQueryResultStatusPropertiesKHR::~safe_VkQueueFamilyQueryResultStatusPropertiesKHR() { … }

void safe_VkQueueFamilyQueryResultStatusPropertiesKHR::initialize(const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkQueueFamilyQueryResultStatusPropertiesKHR::initialize(const safe_VkQueueFamilyQueryResultStatusPropertiesKHR* copy_src,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkQueueFamilyVideoPropertiesKHR::safe_VkQueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkQueueFamilyVideoPropertiesKHR::safe_VkQueueFamilyVideoPropertiesKHR()
    : … { … }

safe_VkQueueFamilyVideoPropertiesKHR::safe_VkQueueFamilyVideoPropertiesKHR(const safe_VkQueueFamilyVideoPropertiesKHR& copy_src) { … }

safe_VkQueueFamilyVideoPropertiesKHR& safe_VkQueueFamilyVideoPropertiesKHR::operator=(
    const safe_VkQueueFamilyVideoPropertiesKHR& copy_src) { … }

safe_VkQueueFamilyVideoPropertiesKHR::~safe_VkQueueFamilyVideoPropertiesKHR() { … }

void safe_VkQueueFamilyVideoPropertiesKHR::initialize(const VkQueueFamilyVideoPropertiesKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkQueueFamilyVideoPropertiesKHR::initialize(const safe_VkQueueFamilyVideoPropertiesKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoProfileInfoKHR::safe_VkVideoProfileInfoKHR(const VkVideoProfileInfoKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoProfileInfoKHR::safe_VkVideoProfileInfoKHR()
    : … { … }

safe_VkVideoProfileInfoKHR::safe_VkVideoProfileInfoKHR(const safe_VkVideoProfileInfoKHR& copy_src) { … }

safe_VkVideoProfileInfoKHR& safe_VkVideoProfileInfoKHR::operator=(const safe_VkVideoProfileInfoKHR& copy_src) { … }

safe_VkVideoProfileInfoKHR::~safe_VkVideoProfileInfoKHR() { … }

void safe_VkVideoProfileInfoKHR::initialize(const VkVideoProfileInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoProfileInfoKHR::initialize(const safe_VkVideoProfileInfoKHR* copy_src,
                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoProfileListInfoKHR::safe_VkVideoProfileListInfoKHR(const VkVideoProfileListInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoProfileListInfoKHR::safe_VkVideoProfileListInfoKHR()
    : … { … }

safe_VkVideoProfileListInfoKHR::safe_VkVideoProfileListInfoKHR(const safe_VkVideoProfileListInfoKHR& copy_src) { … }

safe_VkVideoProfileListInfoKHR& safe_VkVideoProfileListInfoKHR::operator=(const safe_VkVideoProfileListInfoKHR& copy_src) { … }

safe_VkVideoProfileListInfoKHR::~safe_VkVideoProfileListInfoKHR() { … }

void safe_VkVideoProfileListInfoKHR::initialize(const VkVideoProfileListInfoKHR* in_struct,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoProfileListInfoKHR::initialize(const safe_VkVideoProfileListInfoKHR* copy_src,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR* in_struct,
                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR()
    : … { … }

safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR(const safe_VkVideoCapabilitiesKHR& copy_src) { … }

safe_VkVideoCapabilitiesKHR& safe_VkVideoCapabilitiesKHR::operator=(const safe_VkVideoCapabilitiesKHR& copy_src) { … }

safe_VkVideoCapabilitiesKHR::~safe_VkVideoCapabilitiesKHR() { … }

void safe_VkVideoCapabilitiesKHR::initialize(const VkVideoCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoCapabilitiesKHR::initialize(const safe_VkVideoCapabilitiesKHR* copy_src,
                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR(
    const VkPhysicalDeviceVideoFormatInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR()
    : … { … }

safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR(
    const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src) { … }

safe_VkPhysicalDeviceVideoFormatInfoKHR& safe_VkPhysicalDeviceVideoFormatInfoKHR::operator=(
    const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src) { … }

safe_VkPhysicalDeviceVideoFormatInfoKHR::~safe_VkPhysicalDeviceVideoFormatInfoKHR() { … }

void safe_VkPhysicalDeviceVideoFormatInfoKHR::initialize(const VkPhysicalDeviceVideoFormatInfoKHR* in_struct,
                                                         [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceVideoFormatInfoKHR::initialize(const safe_VkPhysicalDeviceVideoFormatInfoKHR* copy_src,
                                                         [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR* in_struct,
                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR()
    : … { … }

safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR(const safe_VkVideoFormatPropertiesKHR& copy_src) { … }

safe_VkVideoFormatPropertiesKHR& safe_VkVideoFormatPropertiesKHR::operator=(const safe_VkVideoFormatPropertiesKHR& copy_src) { … }

safe_VkVideoFormatPropertiesKHR::~safe_VkVideoFormatPropertiesKHR() { … }

void safe_VkVideoFormatPropertiesKHR::initialize(const VkVideoFormatPropertiesKHR* in_struct,
                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoFormatPropertiesKHR::initialize(const safe_VkVideoFormatPropertiesKHR* copy_src,
                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoPictureResourceInfoKHR::safe_VkVideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR* in_struct,
                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoPictureResourceInfoKHR::safe_VkVideoPictureResourceInfoKHR()
    : … { … }

safe_VkVideoPictureResourceInfoKHR::safe_VkVideoPictureResourceInfoKHR(const safe_VkVideoPictureResourceInfoKHR& copy_src) { … }

safe_VkVideoPictureResourceInfoKHR& safe_VkVideoPictureResourceInfoKHR::operator=(
    const safe_VkVideoPictureResourceInfoKHR& copy_src) { … }

safe_VkVideoPictureResourceInfoKHR::~safe_VkVideoPictureResourceInfoKHR() { … }

void safe_VkVideoPictureResourceInfoKHR::initialize(const VkVideoPictureResourceInfoKHR* in_struct,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoPictureResourceInfoKHR::initialize(const safe_VkVideoPictureResourceInfoKHR* copy_src,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoReferenceSlotInfoKHR::safe_VkVideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoReferenceSlotInfoKHR::safe_VkVideoReferenceSlotInfoKHR()
    : … { … }

safe_VkVideoReferenceSlotInfoKHR::safe_VkVideoReferenceSlotInfoKHR(const safe_VkVideoReferenceSlotInfoKHR& copy_src) { … }

safe_VkVideoReferenceSlotInfoKHR& safe_VkVideoReferenceSlotInfoKHR::operator=(const safe_VkVideoReferenceSlotInfoKHR& copy_src) { … }

safe_VkVideoReferenceSlotInfoKHR::~safe_VkVideoReferenceSlotInfoKHR() { … }

void safe_VkVideoReferenceSlotInfoKHR::initialize(const VkVideoReferenceSlotInfoKHR* in_struct,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoReferenceSlotInfoKHR::initialize(const safe_VkVideoReferenceSlotInfoKHR* copy_src,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoSessionMemoryRequirementsKHR::safe_VkVideoSessionMemoryRequirementsKHR(
    const VkVideoSessionMemoryRequirementsKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoSessionMemoryRequirementsKHR::safe_VkVideoSessionMemoryRequirementsKHR()
    : … { … }

safe_VkVideoSessionMemoryRequirementsKHR::safe_VkVideoSessionMemoryRequirementsKHR(
    const safe_VkVideoSessionMemoryRequirementsKHR& copy_src) { … }

safe_VkVideoSessionMemoryRequirementsKHR& safe_VkVideoSessionMemoryRequirementsKHR::operator=(
    const safe_VkVideoSessionMemoryRequirementsKHR& copy_src) { … }

safe_VkVideoSessionMemoryRequirementsKHR::~safe_VkVideoSessionMemoryRequirementsKHR() { … }

void safe_VkVideoSessionMemoryRequirementsKHR::initialize(const VkVideoSessionMemoryRequirementsKHR* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoSessionMemoryRequirementsKHR::initialize(const safe_VkVideoSessionMemoryRequirementsKHR* copy_src,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkBindVideoSessionMemoryInfoKHR::safe_VkBindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkBindVideoSessionMemoryInfoKHR::safe_VkBindVideoSessionMemoryInfoKHR()
    : … { … }

safe_VkBindVideoSessionMemoryInfoKHR::safe_VkBindVideoSessionMemoryInfoKHR(const safe_VkBindVideoSessionMemoryInfoKHR& copy_src) { … }

safe_VkBindVideoSessionMemoryInfoKHR& safe_VkBindVideoSessionMemoryInfoKHR::operator=(
    const safe_VkBindVideoSessionMemoryInfoKHR& copy_src) { … }

safe_VkBindVideoSessionMemoryInfoKHR::~safe_VkBindVideoSessionMemoryInfoKHR() { … }

void safe_VkBindVideoSessionMemoryInfoKHR::initialize(const VkBindVideoSessionMemoryInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkBindVideoSessionMemoryInfoKHR::initialize(const safe_VkBindVideoSessionMemoryInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR()
    : … { … }

safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR(const safe_VkVideoSessionCreateInfoKHR& copy_src) { … }

safe_VkVideoSessionCreateInfoKHR& safe_VkVideoSessionCreateInfoKHR::operator=(const safe_VkVideoSessionCreateInfoKHR& copy_src) { … }

safe_VkVideoSessionCreateInfoKHR::~safe_VkVideoSessionCreateInfoKHR() { … }

void safe_VkVideoSessionCreateInfoKHR::initialize(const VkVideoSessionCreateInfoKHR* in_struct,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoSessionCreateInfoKHR::initialize(const safe_VkVideoSessionCreateInfoKHR* copy_src,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR(
    const VkVideoSessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR()
    : … { … }

safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR(
    const safe_VkVideoSessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoSessionParametersCreateInfoKHR& safe_VkVideoSessionParametersCreateInfoKHR::operator=(
    const safe_VkVideoSessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoSessionParametersCreateInfoKHR::~safe_VkVideoSessionParametersCreateInfoKHR() { … }

void safe_VkVideoSessionParametersCreateInfoKHR::initialize(const VkVideoSessionParametersCreateInfoKHR* in_struct,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoSessionParametersCreateInfoKHR::initialize(const safe_VkVideoSessionParametersCreateInfoKHR* copy_src,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR(
    const VkVideoSessionParametersUpdateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR()
    : … { … }

safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR(
    const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src) { … }

safe_VkVideoSessionParametersUpdateInfoKHR& safe_VkVideoSessionParametersUpdateInfoKHR::operator=(
    const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src) { … }

safe_VkVideoSessionParametersUpdateInfoKHR::~safe_VkVideoSessionParametersUpdateInfoKHR() { … }

void safe_VkVideoSessionParametersUpdateInfoKHR::initialize(const VkVideoSessionParametersUpdateInfoKHR* in_struct,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoSessionParametersUpdateInfoKHR::initialize(const safe_VkVideoSessionParametersUpdateInfoKHR* copy_src,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR()
    : … { … }

safe_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR(const safe_VkVideoBeginCodingInfoKHR& copy_src) { … }

safe_VkVideoBeginCodingInfoKHR& safe_VkVideoBeginCodingInfoKHR::operator=(const safe_VkVideoBeginCodingInfoKHR& copy_src) { … }

safe_VkVideoBeginCodingInfoKHR::~safe_VkVideoBeginCodingInfoKHR() { … }

void safe_VkVideoBeginCodingInfoKHR::initialize(const VkVideoBeginCodingInfoKHR* in_struct,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoBeginCodingInfoKHR::initialize(const safe_VkVideoBeginCodingInfoKHR* copy_src,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR(const VkVideoEndCodingInfoKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR()
    : … { … }

safe_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR(const safe_VkVideoEndCodingInfoKHR& copy_src) { … }

safe_VkVideoEndCodingInfoKHR& safe_VkVideoEndCodingInfoKHR::operator=(const safe_VkVideoEndCodingInfoKHR& copy_src) { … }

safe_VkVideoEndCodingInfoKHR::~safe_VkVideoEndCodingInfoKHR() { … }

void safe_VkVideoEndCodingInfoKHR::initialize(const VkVideoEndCodingInfoKHR* in_struct,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEndCodingInfoKHR::initialize(const safe_VkVideoEndCodingInfoKHR* copy_src,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR()
    : … { … }

safe_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR(const safe_VkVideoCodingControlInfoKHR& copy_src) { … }

safe_VkVideoCodingControlInfoKHR& safe_VkVideoCodingControlInfoKHR::operator=(const safe_VkVideoCodingControlInfoKHR& copy_src) { … }

safe_VkVideoCodingControlInfoKHR::~safe_VkVideoCodingControlInfoKHR() { … }

void safe_VkVideoCodingControlInfoKHR::initialize(const VkVideoCodingControlInfoKHR* in_struct,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoCodingControlInfoKHR::initialize(const safe_VkVideoCodingControlInfoKHR* copy_src,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeCapabilitiesKHR::safe_VkVideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR* in_struct,
                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoDecodeCapabilitiesKHR::safe_VkVideoDecodeCapabilitiesKHR()
    : … { … }

safe_VkVideoDecodeCapabilitiesKHR::safe_VkVideoDecodeCapabilitiesKHR(const safe_VkVideoDecodeCapabilitiesKHR& copy_src) { … }

safe_VkVideoDecodeCapabilitiesKHR& safe_VkVideoDecodeCapabilitiesKHR::operator=(const safe_VkVideoDecodeCapabilitiesKHR& copy_src) { … }

safe_VkVideoDecodeCapabilitiesKHR::~safe_VkVideoDecodeCapabilitiesKHR() { … }

void safe_VkVideoDecodeCapabilitiesKHR::initialize(const VkVideoDecodeCapabilitiesKHR* in_struct,
                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeCapabilitiesKHR::initialize(const safe_VkVideoDecodeCapabilitiesKHR* copy_src,
                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeUsageInfoKHR::safe_VkVideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoDecodeUsageInfoKHR::safe_VkVideoDecodeUsageInfoKHR()
    : … { … }

safe_VkVideoDecodeUsageInfoKHR::safe_VkVideoDecodeUsageInfoKHR(const safe_VkVideoDecodeUsageInfoKHR& copy_src) { … }

safe_VkVideoDecodeUsageInfoKHR& safe_VkVideoDecodeUsageInfoKHR::operator=(const safe_VkVideoDecodeUsageInfoKHR& copy_src) { … }

safe_VkVideoDecodeUsageInfoKHR::~safe_VkVideoDecodeUsageInfoKHR() { … }

void safe_VkVideoDecodeUsageInfoKHR::initialize(const VkVideoDecodeUsageInfoKHR* in_struct,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeUsageInfoKHR::initialize(const safe_VkVideoDecodeUsageInfoKHR* copy_src,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* in_struct,
                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR()
    : … { … }

safe_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR(const safe_VkVideoDecodeInfoKHR& copy_src) { … }

safe_VkVideoDecodeInfoKHR& safe_VkVideoDecodeInfoKHR::operator=(const safe_VkVideoDecodeInfoKHR& copy_src) { … }

safe_VkVideoDecodeInfoKHR::~safe_VkVideoDecodeInfoKHR() { … }

void safe_VkVideoDecodeInfoKHR::initialize(const VkVideoDecodeInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeInfoKHR::initialize(const safe_VkVideoDecodeInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264CapabilitiesKHR::safe_VkVideoEncodeH264CapabilitiesKHR(const VkVideoEncodeH264CapabilitiesKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264CapabilitiesKHR::safe_VkVideoEncodeH264CapabilitiesKHR()
    : … { … }

safe_VkVideoEncodeH264CapabilitiesKHR::safe_VkVideoEncodeH264CapabilitiesKHR(
    const safe_VkVideoEncodeH264CapabilitiesKHR& copy_src) { … }

safe_VkVideoEncodeH264CapabilitiesKHR& safe_VkVideoEncodeH264CapabilitiesKHR::operator=(
    const safe_VkVideoEncodeH264CapabilitiesKHR& copy_src) { … }

safe_VkVideoEncodeH264CapabilitiesKHR::~safe_VkVideoEncodeH264CapabilitiesKHR() { … }

void safe_VkVideoEncodeH264CapabilitiesKHR::initialize(const VkVideoEncodeH264CapabilitiesKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264CapabilitiesKHR::initialize(const safe_VkVideoEncodeH264CapabilitiesKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264QualityLevelPropertiesKHR::safe_VkVideoEncodeH264QualityLevelPropertiesKHR(
    const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264QualityLevelPropertiesKHR::safe_VkVideoEncodeH264QualityLevelPropertiesKHR()
    : … { … }

safe_VkVideoEncodeH264QualityLevelPropertiesKHR::safe_VkVideoEncodeH264QualityLevelPropertiesKHR(
    const safe_VkVideoEncodeH264QualityLevelPropertiesKHR& copy_src) { … }

safe_VkVideoEncodeH264QualityLevelPropertiesKHR& safe_VkVideoEncodeH264QualityLevelPropertiesKHR::operator=(
    const safe_VkVideoEncodeH264QualityLevelPropertiesKHR& copy_src) { … }

safe_VkVideoEncodeH264QualityLevelPropertiesKHR::~safe_VkVideoEncodeH264QualityLevelPropertiesKHR() { … }

void safe_VkVideoEncodeH264QualityLevelPropertiesKHR::initialize(const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct,
                                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264QualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeH264QualityLevelPropertiesKHR* copy_src,
                                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264SessionCreateInfoKHR::safe_VkVideoEncodeH264SessionCreateInfoKHR(
    const VkVideoEncodeH264SessionCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264SessionCreateInfoKHR::safe_VkVideoEncodeH264SessionCreateInfoKHR()
    : … { … }

safe_VkVideoEncodeH264SessionCreateInfoKHR::safe_VkVideoEncodeH264SessionCreateInfoKHR(
    const safe_VkVideoEncodeH264SessionCreateInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264SessionCreateInfoKHR& safe_VkVideoEncodeH264SessionCreateInfoKHR::operator=(
    const safe_VkVideoEncodeH264SessionCreateInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264SessionCreateInfoKHR::~safe_VkVideoEncodeH264SessionCreateInfoKHR() { … }

void safe_VkVideoEncodeH264SessionCreateInfoKHR::initialize(const VkVideoEncodeH264SessionCreateInfoKHR* in_struct,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264SessionCreateInfoKHR::initialize(const safe_VkVideoEncodeH264SessionCreateInfoKHR* copy_src,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264SessionParametersAddInfoKHR::safe_VkVideoEncodeH264SessionParametersAddInfoKHR(
    const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264SessionParametersAddInfoKHR::safe_VkVideoEncodeH264SessionParametersAddInfoKHR()
    : … { … }

safe_VkVideoEncodeH264SessionParametersAddInfoKHR::safe_VkVideoEncodeH264SessionParametersAddInfoKHR(
    const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264SessionParametersAddInfoKHR& safe_VkVideoEncodeH264SessionParametersAddInfoKHR::operator=(
    const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264SessionParametersAddInfoKHR::~safe_VkVideoEncodeH264SessionParametersAddInfoKHR() { … }

void safe_VkVideoEncodeH264SessionParametersAddInfoKHR::initialize(const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264SessionParametersAddInfoKHR::initialize(
    const safe_VkVideoEncodeH264SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(
    const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::safe_VkVideoEncodeH264SessionParametersCreateInfoKHR()
    : … { … }

safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(
    const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::operator=(
    const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::~safe_VkVideoEncodeH264SessionParametersCreateInfoKHR() { … }

void safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::initialize(
    const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::initialize(
    const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264SessionParametersGetInfoKHR::safe_VkVideoEncodeH264SessionParametersGetInfoKHR(
    const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264SessionParametersGetInfoKHR::safe_VkVideoEncodeH264SessionParametersGetInfoKHR()
    : … { … }

safe_VkVideoEncodeH264SessionParametersGetInfoKHR::safe_VkVideoEncodeH264SessionParametersGetInfoKHR(
    const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264SessionParametersGetInfoKHR& safe_VkVideoEncodeH264SessionParametersGetInfoKHR::operator=(
    const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264SessionParametersGetInfoKHR::~safe_VkVideoEncodeH264SessionParametersGetInfoKHR() { … }

void safe_VkVideoEncodeH264SessionParametersGetInfoKHR::initialize(const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264SessionParametersGetInfoKHR::initialize(
    const safe_VkVideoEncodeH264SessionParametersGetInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(
    const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR()
    : … { … }

safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(
    const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::operator=(
    const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR() { … }

void safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::initialize(
    const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::initialize(
    const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264NaluSliceInfoKHR::safe_VkVideoEncodeH264NaluSliceInfoKHR(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct,
                                                                               [[maybe_unused]] PNextCopyState* copy_state,
                                                                               bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264NaluSliceInfoKHR::safe_VkVideoEncodeH264NaluSliceInfoKHR()
    : … { … }

safe_VkVideoEncodeH264NaluSliceInfoKHR::safe_VkVideoEncodeH264NaluSliceInfoKHR(
    const safe_VkVideoEncodeH264NaluSliceInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264NaluSliceInfoKHR& safe_VkVideoEncodeH264NaluSliceInfoKHR::operator=(
    const safe_VkVideoEncodeH264NaluSliceInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264NaluSliceInfoKHR::~safe_VkVideoEncodeH264NaluSliceInfoKHR() { … }

void safe_VkVideoEncodeH264NaluSliceInfoKHR::initialize(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct,
                                                        [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264NaluSliceInfoKHR::initialize(const safe_VkVideoEncodeH264NaluSliceInfoKHR* copy_src,
                                                        [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR(const VkVideoEncodeH264PictureInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR()
    : … { … }

safe_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR(const safe_VkVideoEncodeH264PictureInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264PictureInfoKHR& safe_VkVideoEncodeH264PictureInfoKHR::operator=(
    const safe_VkVideoEncodeH264PictureInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264PictureInfoKHR::~safe_VkVideoEncodeH264PictureInfoKHR() { … }

void safe_VkVideoEncodeH264PictureInfoKHR::initialize(const VkVideoEncodeH264PictureInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264PictureInfoKHR::initialize(const safe_VkVideoEncodeH264PictureInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264DpbSlotInfoKHR::safe_VkVideoEncodeH264DpbSlotInfoKHR(const VkVideoEncodeH264DpbSlotInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264DpbSlotInfoKHR::safe_VkVideoEncodeH264DpbSlotInfoKHR()
    : … { … }

safe_VkVideoEncodeH264DpbSlotInfoKHR::safe_VkVideoEncodeH264DpbSlotInfoKHR(const safe_VkVideoEncodeH264DpbSlotInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264DpbSlotInfoKHR& safe_VkVideoEncodeH264DpbSlotInfoKHR::operator=(
    const safe_VkVideoEncodeH264DpbSlotInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264DpbSlotInfoKHR::~safe_VkVideoEncodeH264DpbSlotInfoKHR() { … }

void safe_VkVideoEncodeH264DpbSlotInfoKHR::initialize(const VkVideoEncodeH264DpbSlotInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264DpbSlotInfoKHR::initialize(const safe_VkVideoEncodeH264DpbSlotInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264ProfileInfoKHR::safe_VkVideoEncodeH264ProfileInfoKHR(const VkVideoEncodeH264ProfileInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264ProfileInfoKHR::safe_VkVideoEncodeH264ProfileInfoKHR()
    : … { … }

safe_VkVideoEncodeH264ProfileInfoKHR::safe_VkVideoEncodeH264ProfileInfoKHR(const safe_VkVideoEncodeH264ProfileInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264ProfileInfoKHR& safe_VkVideoEncodeH264ProfileInfoKHR::operator=(
    const safe_VkVideoEncodeH264ProfileInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264ProfileInfoKHR::~safe_VkVideoEncodeH264ProfileInfoKHR() { … }

void safe_VkVideoEncodeH264ProfileInfoKHR::initialize(const VkVideoEncodeH264ProfileInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264ProfileInfoKHR::initialize(const safe_VkVideoEncodeH264ProfileInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264RateControlInfoKHR::safe_VkVideoEncodeH264RateControlInfoKHR(
    const VkVideoEncodeH264RateControlInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264RateControlInfoKHR::safe_VkVideoEncodeH264RateControlInfoKHR()
    : … { … }

safe_VkVideoEncodeH264RateControlInfoKHR::safe_VkVideoEncodeH264RateControlInfoKHR(
    const safe_VkVideoEncodeH264RateControlInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264RateControlInfoKHR& safe_VkVideoEncodeH264RateControlInfoKHR::operator=(
    const safe_VkVideoEncodeH264RateControlInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264RateControlInfoKHR::~safe_VkVideoEncodeH264RateControlInfoKHR() { … }

void safe_VkVideoEncodeH264RateControlInfoKHR::initialize(const VkVideoEncodeH264RateControlInfoKHR* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264RateControlInfoKHR::initialize(const safe_VkVideoEncodeH264RateControlInfoKHR* copy_src,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264RateControlLayerInfoKHR::safe_VkVideoEncodeH264RateControlLayerInfoKHR(
    const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264RateControlLayerInfoKHR::safe_VkVideoEncodeH264RateControlLayerInfoKHR()
    : … { … }

safe_VkVideoEncodeH264RateControlLayerInfoKHR::safe_VkVideoEncodeH264RateControlLayerInfoKHR(
    const safe_VkVideoEncodeH264RateControlLayerInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264RateControlLayerInfoKHR& safe_VkVideoEncodeH264RateControlLayerInfoKHR::operator=(
    const safe_VkVideoEncodeH264RateControlLayerInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264RateControlLayerInfoKHR::~safe_VkVideoEncodeH264RateControlLayerInfoKHR() { … }

void safe_VkVideoEncodeH264RateControlLayerInfoKHR::initialize(const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264RateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeH264RateControlLayerInfoKHR* copy_src,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(
    const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::safe_VkVideoEncodeH264GopRemainingFrameInfoKHR()
    : … { … }

safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(
    const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::operator=(
    const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& copy_src) { … }

safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::~safe_VkVideoEncodeH264GopRemainingFrameInfoKHR() { … }

void safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::initialize(const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::initialize(const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR* copy_src,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265CapabilitiesKHR::safe_VkVideoEncodeH265CapabilitiesKHR(const VkVideoEncodeH265CapabilitiesKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265CapabilitiesKHR::safe_VkVideoEncodeH265CapabilitiesKHR()
    : … { … }

safe_VkVideoEncodeH265CapabilitiesKHR::safe_VkVideoEncodeH265CapabilitiesKHR(
    const safe_VkVideoEncodeH265CapabilitiesKHR& copy_src) { … }

safe_VkVideoEncodeH265CapabilitiesKHR& safe_VkVideoEncodeH265CapabilitiesKHR::operator=(
    const safe_VkVideoEncodeH265CapabilitiesKHR& copy_src) { … }

safe_VkVideoEncodeH265CapabilitiesKHR::~safe_VkVideoEncodeH265CapabilitiesKHR() { … }

void safe_VkVideoEncodeH265CapabilitiesKHR::initialize(const VkVideoEncodeH265CapabilitiesKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265CapabilitiesKHR::initialize(const safe_VkVideoEncodeH265CapabilitiesKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265SessionCreateInfoKHR::safe_VkVideoEncodeH265SessionCreateInfoKHR(
    const VkVideoEncodeH265SessionCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265SessionCreateInfoKHR::safe_VkVideoEncodeH265SessionCreateInfoKHR()
    : … { … }

safe_VkVideoEncodeH265SessionCreateInfoKHR::safe_VkVideoEncodeH265SessionCreateInfoKHR(
    const safe_VkVideoEncodeH265SessionCreateInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265SessionCreateInfoKHR& safe_VkVideoEncodeH265SessionCreateInfoKHR::operator=(
    const safe_VkVideoEncodeH265SessionCreateInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265SessionCreateInfoKHR::~safe_VkVideoEncodeH265SessionCreateInfoKHR() { … }

void safe_VkVideoEncodeH265SessionCreateInfoKHR::initialize(const VkVideoEncodeH265SessionCreateInfoKHR* in_struct,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265SessionCreateInfoKHR::initialize(const safe_VkVideoEncodeH265SessionCreateInfoKHR* copy_src,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265QualityLevelPropertiesKHR::safe_VkVideoEncodeH265QualityLevelPropertiesKHR(
    const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265QualityLevelPropertiesKHR::safe_VkVideoEncodeH265QualityLevelPropertiesKHR()
    : … { … }

safe_VkVideoEncodeH265QualityLevelPropertiesKHR::safe_VkVideoEncodeH265QualityLevelPropertiesKHR(
    const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& copy_src) { … }

safe_VkVideoEncodeH265QualityLevelPropertiesKHR& safe_VkVideoEncodeH265QualityLevelPropertiesKHR::operator=(
    const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& copy_src) { … }

safe_VkVideoEncodeH265QualityLevelPropertiesKHR::~safe_VkVideoEncodeH265QualityLevelPropertiesKHR() { … }

void safe_VkVideoEncodeH265QualityLevelPropertiesKHR::initialize(const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct,
                                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265QualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeH265QualityLevelPropertiesKHR* copy_src,
                                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR(
    const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR()
    : … { … }

safe_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR(
    const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265SessionParametersAddInfoKHR& safe_VkVideoEncodeH265SessionParametersAddInfoKHR::operator=(
    const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265SessionParametersAddInfoKHR::~safe_VkVideoEncodeH265SessionParametersAddInfoKHR() { … }

void safe_VkVideoEncodeH265SessionParametersAddInfoKHR::initialize(const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265SessionParametersAddInfoKHR::initialize(
    const safe_VkVideoEncodeH265SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(
    const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR()
    : … { … }

safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(
    const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::operator=(
    const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::~safe_VkVideoEncodeH265SessionParametersCreateInfoKHR() { … }

void safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::initialize(
    const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::initialize(
    const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265SessionParametersGetInfoKHR::safe_VkVideoEncodeH265SessionParametersGetInfoKHR(
    const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265SessionParametersGetInfoKHR::safe_VkVideoEncodeH265SessionParametersGetInfoKHR()
    : … { … }

safe_VkVideoEncodeH265SessionParametersGetInfoKHR::safe_VkVideoEncodeH265SessionParametersGetInfoKHR(
    const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265SessionParametersGetInfoKHR& safe_VkVideoEncodeH265SessionParametersGetInfoKHR::operator=(
    const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265SessionParametersGetInfoKHR::~safe_VkVideoEncodeH265SessionParametersGetInfoKHR() { … }

void safe_VkVideoEncodeH265SessionParametersGetInfoKHR::initialize(const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265SessionParametersGetInfoKHR::initialize(
    const safe_VkVideoEncodeH265SessionParametersGetInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(
    const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR()
    : … { … }

safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(
    const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::operator=(
    const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR() { … }

void safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::initialize(
    const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::initialize(
    const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR(
    const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR()
    : … { … }

safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR(
    const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::operator=(
    const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::~safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR() { … }

void safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::initialize(const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::initialize(const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR* copy_src,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR(const VkVideoEncodeH265PictureInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR()
    : … { … }

safe_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR(const safe_VkVideoEncodeH265PictureInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265PictureInfoKHR& safe_VkVideoEncodeH265PictureInfoKHR::operator=(
    const safe_VkVideoEncodeH265PictureInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265PictureInfoKHR::~safe_VkVideoEncodeH265PictureInfoKHR() { … }

void safe_VkVideoEncodeH265PictureInfoKHR::initialize(const VkVideoEncodeH265PictureInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265PictureInfoKHR::initialize(const safe_VkVideoEncodeH265PictureInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265DpbSlotInfoKHR::safe_VkVideoEncodeH265DpbSlotInfoKHR(const VkVideoEncodeH265DpbSlotInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265DpbSlotInfoKHR::safe_VkVideoEncodeH265DpbSlotInfoKHR()
    : … { … }

safe_VkVideoEncodeH265DpbSlotInfoKHR::safe_VkVideoEncodeH265DpbSlotInfoKHR(const safe_VkVideoEncodeH265DpbSlotInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265DpbSlotInfoKHR& safe_VkVideoEncodeH265DpbSlotInfoKHR::operator=(
    const safe_VkVideoEncodeH265DpbSlotInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265DpbSlotInfoKHR::~safe_VkVideoEncodeH265DpbSlotInfoKHR() { … }

void safe_VkVideoEncodeH265DpbSlotInfoKHR::initialize(const VkVideoEncodeH265DpbSlotInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265DpbSlotInfoKHR::initialize(const safe_VkVideoEncodeH265DpbSlotInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265ProfileInfoKHR::safe_VkVideoEncodeH265ProfileInfoKHR(const VkVideoEncodeH265ProfileInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265ProfileInfoKHR::safe_VkVideoEncodeH265ProfileInfoKHR()
    : … { … }

safe_VkVideoEncodeH265ProfileInfoKHR::safe_VkVideoEncodeH265ProfileInfoKHR(const safe_VkVideoEncodeH265ProfileInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265ProfileInfoKHR& safe_VkVideoEncodeH265ProfileInfoKHR::operator=(
    const safe_VkVideoEncodeH265ProfileInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265ProfileInfoKHR::~safe_VkVideoEncodeH265ProfileInfoKHR() { … }

void safe_VkVideoEncodeH265ProfileInfoKHR::initialize(const VkVideoEncodeH265ProfileInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265ProfileInfoKHR::initialize(const safe_VkVideoEncodeH265ProfileInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265RateControlInfoKHR::safe_VkVideoEncodeH265RateControlInfoKHR(
    const VkVideoEncodeH265RateControlInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265RateControlInfoKHR::safe_VkVideoEncodeH265RateControlInfoKHR()
    : … { … }

safe_VkVideoEncodeH265RateControlInfoKHR::safe_VkVideoEncodeH265RateControlInfoKHR(
    const safe_VkVideoEncodeH265RateControlInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265RateControlInfoKHR& safe_VkVideoEncodeH265RateControlInfoKHR::operator=(
    const safe_VkVideoEncodeH265RateControlInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265RateControlInfoKHR::~safe_VkVideoEncodeH265RateControlInfoKHR() { … }

void safe_VkVideoEncodeH265RateControlInfoKHR::initialize(const VkVideoEncodeH265RateControlInfoKHR* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265RateControlInfoKHR::initialize(const safe_VkVideoEncodeH265RateControlInfoKHR* copy_src,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265RateControlLayerInfoKHR::safe_VkVideoEncodeH265RateControlLayerInfoKHR(
    const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265RateControlLayerInfoKHR::safe_VkVideoEncodeH265RateControlLayerInfoKHR()
    : … { … }

safe_VkVideoEncodeH265RateControlLayerInfoKHR::safe_VkVideoEncodeH265RateControlLayerInfoKHR(
    const safe_VkVideoEncodeH265RateControlLayerInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265RateControlLayerInfoKHR& safe_VkVideoEncodeH265RateControlLayerInfoKHR::operator=(
    const safe_VkVideoEncodeH265RateControlLayerInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265RateControlLayerInfoKHR::~safe_VkVideoEncodeH265RateControlLayerInfoKHR() { … }

void safe_VkVideoEncodeH265RateControlLayerInfoKHR::initialize(const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265RateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeH265RateControlLayerInfoKHR* copy_src,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(
    const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::safe_VkVideoEncodeH265GopRemainingFrameInfoKHR()
    : … { … }

safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(
    const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::operator=(
    const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& copy_src) { … }

safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::~safe_VkVideoEncodeH265GopRemainingFrameInfoKHR() { … }

void safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::initialize(const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::initialize(const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR* copy_src,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR()
    : … { … }

safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR(const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src) { … }

safe_VkVideoDecodeH264ProfileInfoKHR& safe_VkVideoDecodeH264ProfileInfoKHR::operator=(
    const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src) { … }

safe_VkVideoDecodeH264ProfileInfoKHR::~safe_VkVideoDecodeH264ProfileInfoKHR() { … }

void safe_VkVideoDecodeH264ProfileInfoKHR::initialize(const VkVideoDecodeH264ProfileInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH264ProfileInfoKHR::initialize(const safe_VkVideoDecodeH264ProfileInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR()
    : … { … }

safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR(
    const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src) { … }

safe_VkVideoDecodeH264CapabilitiesKHR& safe_VkVideoDecodeH264CapabilitiesKHR::operator=(
    const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src) { … }

safe_VkVideoDecodeH264CapabilitiesKHR::~safe_VkVideoDecodeH264CapabilitiesKHR() { … }

void safe_VkVideoDecodeH264CapabilitiesKHR::initialize(const VkVideoDecodeH264CapabilitiesKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH264CapabilitiesKHR::initialize(const safe_VkVideoDecodeH264CapabilitiesKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR(
    const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR()
    : … { … }

safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR(
    const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src) { … }

safe_VkVideoDecodeH264SessionParametersAddInfoKHR& safe_VkVideoDecodeH264SessionParametersAddInfoKHR::operator=(
    const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src) { … }

safe_VkVideoDecodeH264SessionParametersAddInfoKHR::~safe_VkVideoDecodeH264SessionParametersAddInfoKHR() { … }

void safe_VkVideoDecodeH264SessionParametersAddInfoKHR::initialize(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH264SessionParametersAddInfoKHR::initialize(
    const safe_VkVideoDecodeH264SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(
    const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR()
    : … { … }

safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(
    const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::operator=(
    const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::~safe_VkVideoDecodeH264SessionParametersCreateInfoKHR() { … }

void safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::initialize(
    const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::initialize(
    const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR()
    : … { … }

safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR(const safe_VkVideoDecodeH264PictureInfoKHR& copy_src) { … }

safe_VkVideoDecodeH264PictureInfoKHR& safe_VkVideoDecodeH264PictureInfoKHR::operator=(
    const safe_VkVideoDecodeH264PictureInfoKHR& copy_src) { … }

safe_VkVideoDecodeH264PictureInfoKHR::~safe_VkVideoDecodeH264PictureInfoKHR() { … }

void safe_VkVideoDecodeH264PictureInfoKHR::initialize(const VkVideoDecodeH264PictureInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH264PictureInfoKHR::initialize(const safe_VkVideoDecodeH264PictureInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR()
    : … { … }

safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR(const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src) { … }

safe_VkVideoDecodeH264DpbSlotInfoKHR& safe_VkVideoDecodeH264DpbSlotInfoKHR::operator=(
    const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src) { … }

safe_VkVideoDecodeH264DpbSlotInfoKHR::~safe_VkVideoDecodeH264DpbSlotInfoKHR() { … }

void safe_VkVideoDecodeH264DpbSlotInfoKHR::initialize(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH264DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH264DpbSlotInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(
    const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR()
    : … { … }

safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(
    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) { … }

safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::operator=(
    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) { … }

safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR() { … }

void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize(
    const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize(
    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }
#ifdef VK_USE_PLATFORM_WIN32_KHR

safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : sType(in_struct->sType), handleType(in_struct->handleType), handle(in_struct->handle), name(in_struct->name) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
}

safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR()
    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR), pNext(nullptr), handleType(), handle(), name() {}

safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(
    const safe_VkImportMemoryWin32HandleInfoKHR& copy_src) {
    sType = copy_src.sType;
    handleType = copy_src.handleType;
    handle = copy_src.handle;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);
}

safe_VkImportMemoryWin32HandleInfoKHR& safe_VkImportMemoryWin32HandleInfoKHR::operator=(
    const safe_VkImportMemoryWin32HandleInfoKHR& copy_src) {
    if (&copy_src == this) return *this;

    FreePnextChain(pNext);

    sType = copy_src.sType;
    handleType = copy_src.handleType;
    handle = copy_src.handle;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);

    return *this;
}

safe_VkImportMemoryWin32HandleInfoKHR::~safe_VkImportMemoryWin32HandleInfoKHR() { FreePnextChain(pNext); }

void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) {
    FreePnextChain(pNext);
    sType = in_struct->sType;
    handleType = in_struct->handleType;
    handle = in_struct->handle;
    name = in_struct->name;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);
}

void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const safe_VkImportMemoryWin32HandleInfoKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    handleType = copy_src->handleType;
    handle = copy_src->handle;
    name = copy_src->name;
    pNext = SafePnextCopy(copy_src->pNext);
}

safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
    if (in_struct->pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
    }
}

safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR()
    : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {}

safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(
    const safe_VkExportMemoryWin32HandleInfoKHR& copy_src) {
    sType = copy_src.sType;
    pAttributes = nullptr;
    dwAccess = copy_src.dwAccess;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);

    if (copy_src.pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
    }
}

safe_VkExportMemoryWin32HandleInfoKHR& safe_VkExportMemoryWin32HandleInfoKHR::operator=(
    const safe_VkExportMemoryWin32HandleInfoKHR& copy_src) {
    if (&copy_src == this) return *this;

    if (pAttributes) delete pAttributes;
    FreePnextChain(pNext);

    sType = copy_src.sType;
    pAttributes = nullptr;
    dwAccess = copy_src.dwAccess;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);

    if (copy_src.pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
    }

    return *this;
}

safe_VkExportMemoryWin32HandleInfoKHR::~safe_VkExportMemoryWin32HandleInfoKHR() {
    if (pAttributes) delete pAttributes;
    FreePnextChain(pNext);
}

void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) {
    if (pAttributes) delete pAttributes;
    FreePnextChain(pNext);
    sType = in_struct->sType;
    pAttributes = nullptr;
    dwAccess = in_struct->dwAccess;
    name = in_struct->name;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);

    if (in_struct->pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
    }
}

void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const safe_VkExportMemoryWin32HandleInfoKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    pAttributes = nullptr;
    dwAccess = copy_src->dwAccess;
    name = copy_src->name;
    pNext = SafePnextCopy(copy_src->pNext);

    if (copy_src->pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes);
    }
}

safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : sType(in_struct->sType), memoryTypeBits(in_struct->memoryTypeBits) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
}

safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR()
    : sType(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR), pNext(nullptr), memoryTypeBits() {}

safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(
    const safe_VkMemoryWin32HandlePropertiesKHR& copy_src) {
    sType = copy_src.sType;
    memoryTypeBits = copy_src.memoryTypeBits;
    pNext = SafePnextCopy(copy_src.pNext);
}

safe_VkMemoryWin32HandlePropertiesKHR& safe_VkMemoryWin32HandlePropertiesKHR::operator=(
    const safe_VkMemoryWin32HandlePropertiesKHR& copy_src) {
    if (&copy_src == this) return *this;

    FreePnextChain(pNext);

    sType = copy_src.sType;
    memoryTypeBits = copy_src.memoryTypeBits;
    pNext = SafePnextCopy(copy_src.pNext);

    return *this;
}

safe_VkMemoryWin32HandlePropertiesKHR::~safe_VkMemoryWin32HandlePropertiesKHR() { FreePnextChain(pNext); }

void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) {
    FreePnextChain(pNext);
    sType = in_struct->sType;
    memoryTypeBits = in_struct->memoryTypeBits;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);
}

void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const safe_VkMemoryWin32HandlePropertiesKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    memoryTypeBits = copy_src->memoryTypeBits;
    pNext = SafePnextCopy(copy_src->pNext);
}

safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct,
                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : sType(in_struct->sType), memory(in_struct->memory), handleType(in_struct->handleType) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
}

safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR()
    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), memory(), handleType() {}

safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src) {
    sType = copy_src.sType;
    memory = copy_src.memory;
    handleType = copy_src.handleType;
    pNext = SafePnextCopy(copy_src.pNext);
}

safe_VkMemoryGetWin32HandleInfoKHR& safe_VkMemoryGetWin32HandleInfoKHR::operator=(
    const safe_VkMemoryGetWin32HandleInfoKHR& copy_src) {
    if (&copy_src == this) return *this;

    FreePnextChain(pNext);

    sType = copy_src.sType;
    memory = copy_src.memory;
    handleType = copy_src.handleType;
    pNext = SafePnextCopy(copy_src.pNext);

    return *this;
}

safe_VkMemoryGetWin32HandleInfoKHR::~safe_VkMemoryGetWin32HandleInfoKHR() { FreePnextChain(pNext); }

void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct,
                                                    [[maybe_unused]] PNextCopyState* copy_state) {
    FreePnextChain(pNext);
    sType = in_struct->sType;
    memory = in_struct->memory;
    handleType = in_struct->handleType;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);
}

void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const safe_VkMemoryGetWin32HandleInfoKHR* copy_src,
                                                    [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    memory = copy_src->memory;
    handleType = copy_src->handleType;
    pNext = SafePnextCopy(copy_src->pNext);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR()
    : … { … }

safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& copy_src) { … }

safe_VkImportMemoryFdInfoKHR& safe_VkImportMemoryFdInfoKHR::operator=(const safe_VkImportMemoryFdInfoKHR& copy_src) { … }

safe_VkImportMemoryFdInfoKHR::~safe_VkImportMemoryFdInfoKHR() { … }

void safe_VkImportMemoryFdInfoKHR::initialize(const VkImportMemoryFdInfoKHR* in_struct,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkImportMemoryFdInfoKHR::initialize(const safe_VkImportMemoryFdInfoKHR* copy_src,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR()
    : … { … }

safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& copy_src) { … }

safe_VkMemoryFdPropertiesKHR& safe_VkMemoryFdPropertiesKHR::operator=(const safe_VkMemoryFdPropertiesKHR& copy_src) { … }

safe_VkMemoryFdPropertiesKHR::~safe_VkMemoryFdPropertiesKHR() { … }

void safe_VkMemoryFdPropertiesKHR::initialize(const VkMemoryFdPropertiesKHR* in_struct,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkMemoryFdPropertiesKHR::initialize(const safe_VkMemoryFdPropertiesKHR* copy_src,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct,
                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR()
    : … { … }

safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& copy_src) { … }

safe_VkMemoryGetFdInfoKHR& safe_VkMemoryGetFdInfoKHR::operator=(const safe_VkMemoryGetFdInfoKHR& copy_src) { … }

safe_VkMemoryGetFdInfoKHR::~safe_VkMemoryGetFdInfoKHR() { … }

void safe_VkMemoryGetFdInfoKHR::initialize(const VkMemoryGetFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkMemoryGetFdInfoKHR::initialize(const safe_VkMemoryGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }
#ifdef VK_USE_PLATFORM_WIN32_KHR

safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(
    const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : sType(in_struct->sType),
      acquireCount(in_struct->acquireCount),
      pAcquireSyncs(nullptr),
      pAcquireKeys(nullptr),
      pAcquireTimeouts(nullptr),
      releaseCount(in_struct->releaseCount),
      pReleaseSyncs(nullptr),
      pReleaseKeys(nullptr) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
    if (acquireCount && in_struct->pAcquireSyncs) {
        pAcquireSyncs = new VkDeviceMemory[acquireCount];
        for (uint32_t i = 0; i < acquireCount; ++i) {
            pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
        }
    }

    if (in_struct->pAcquireKeys) {
        pAcquireKeys = new uint64_t[in_struct->acquireCount];
        memcpy((void*)pAcquireKeys, (void*)in_struct->pAcquireKeys, sizeof(uint64_t) * in_struct->acquireCount);
    }

    if (in_struct->pAcquireTimeouts) {
        pAcquireTimeouts = new uint32_t[in_struct->acquireCount];
        memcpy((void*)pAcquireTimeouts, (void*)in_struct->pAcquireTimeouts, sizeof(uint32_t) * in_struct->acquireCount);
    }
    if (releaseCount && in_struct->pReleaseSyncs) {
        pReleaseSyncs = new VkDeviceMemory[releaseCount];
        for (uint32_t i = 0; i < releaseCount; ++i) {
            pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
        }
    }

    if (in_struct->pReleaseKeys) {
        pReleaseKeys = new uint64_t[in_struct->releaseCount];
        memcpy((void*)pReleaseKeys, (void*)in_struct->pReleaseKeys, sizeof(uint64_t) * in_struct->releaseCount);
    }
}

safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR()
    : sType(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR),
      pNext(nullptr),
      acquireCount(),
      pAcquireSyncs(nullptr),
      pAcquireKeys(nullptr),
      pAcquireTimeouts(nullptr),
      releaseCount(),
      pReleaseSyncs(nullptr),
      pReleaseKeys(nullptr) {}

safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(
    const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src) {
    sType = copy_src.sType;
    acquireCount = copy_src.acquireCount;
    pAcquireSyncs = nullptr;
    pAcquireKeys = nullptr;
    pAcquireTimeouts = nullptr;
    releaseCount = copy_src.releaseCount;
    pReleaseSyncs = nullptr;
    pReleaseKeys = nullptr;
    pNext = SafePnextCopy(copy_src.pNext);
    if (acquireCount && copy_src.pAcquireSyncs) {
        pAcquireSyncs = new VkDeviceMemory[acquireCount];
        for (uint32_t i = 0; i < acquireCount; ++i) {
            pAcquireSyncs[i] = copy_src.pAcquireSyncs[i];
        }
    }

    if (copy_src.pAcquireKeys) {
        pAcquireKeys = new uint64_t[copy_src.acquireCount];
        memcpy((void*)pAcquireKeys, (void*)copy_src.pAcquireKeys, sizeof(uint64_t) * copy_src.acquireCount);
    }

    if (copy_src.pAcquireTimeouts) {
        pAcquireTimeouts = new uint32_t[copy_src.acquireCount];
        memcpy((void*)pAcquireTimeouts, (void*)copy_src.pAcquireTimeouts, sizeof(uint32_t) * copy_src.acquireCount);
    }
    if (releaseCount && copy_src.pReleaseSyncs) {
        pReleaseSyncs = new VkDeviceMemory[releaseCount];
        for (uint32_t i = 0; i < releaseCount; ++i) {
            pReleaseSyncs[i] = copy_src.pReleaseSyncs[i];
        }
    }

    if (copy_src.pReleaseKeys) {
        pReleaseKeys = new uint64_t[copy_src.releaseCount];
        memcpy((void*)pReleaseKeys, (void*)copy_src.pReleaseKeys, sizeof(uint64_t) * copy_src.releaseCount);
    }
}

safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::operator=(
    const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src) {
    if (&copy_src == this) return *this;

    if (pAcquireSyncs) delete[] pAcquireSyncs;
    if (pAcquireKeys) delete[] pAcquireKeys;
    if (pAcquireTimeouts) delete[] pAcquireTimeouts;
    if (pReleaseSyncs) delete[] pReleaseSyncs;
    if (pReleaseKeys) delete[] pReleaseKeys;
    FreePnextChain(pNext);

    sType = copy_src.sType;
    acquireCount = copy_src.acquireCount;
    pAcquireSyncs = nullptr;
    pAcquireKeys = nullptr;
    pAcquireTimeouts = nullptr;
    releaseCount = copy_src.releaseCount;
    pReleaseSyncs = nullptr;
    pReleaseKeys = nullptr;
    pNext = SafePnextCopy(copy_src.pNext);
    if (acquireCount && copy_src.pAcquireSyncs) {
        pAcquireSyncs = new VkDeviceMemory[acquireCount];
        for (uint32_t i = 0; i < acquireCount; ++i) {
            pAcquireSyncs[i] = copy_src.pAcquireSyncs[i];
        }
    }

    if (copy_src.pAcquireKeys) {
        pAcquireKeys = new uint64_t[copy_src.acquireCount];
        memcpy((void*)pAcquireKeys, (void*)copy_src.pAcquireKeys, sizeof(uint64_t) * copy_src.acquireCount);
    }

    if (copy_src.pAcquireTimeouts) {
        pAcquireTimeouts = new uint32_t[copy_src.acquireCount];
        memcpy((void*)pAcquireTimeouts, (void*)copy_src.pAcquireTimeouts, sizeof(uint32_t) * copy_src.acquireCount);
    }
    if (releaseCount && copy_src.pReleaseSyncs) {
        pReleaseSyncs = new VkDeviceMemory[releaseCount];
        for (uint32_t i = 0; i < releaseCount; ++i) {
            pReleaseSyncs[i] = copy_src.pReleaseSyncs[i];
        }
    }

    if (copy_src.pReleaseKeys) {
        pReleaseKeys = new uint64_t[copy_src.releaseCount];
        memcpy((void*)pReleaseKeys, (void*)copy_src.pReleaseKeys, sizeof(uint64_t) * copy_src.releaseCount);
    }

    return *this;
}

safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR() {
    if (pAcquireSyncs) delete[] pAcquireSyncs;
    if (pAcquireKeys) delete[] pAcquireKeys;
    if (pAcquireTimeouts) delete[] pAcquireTimeouts;
    if (pReleaseSyncs) delete[] pReleaseSyncs;
    if (pReleaseKeys) delete[] pReleaseKeys;
    FreePnextChain(pNext);
}

void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct,
                                                             [[maybe_unused]] PNextCopyState* copy_state) {
    if (pAcquireSyncs) delete[] pAcquireSyncs;
    if (pAcquireKeys) delete[] pAcquireKeys;
    if (pAcquireTimeouts) delete[] pAcquireTimeouts;
    if (pReleaseSyncs) delete[] pReleaseSyncs;
    if (pReleaseKeys) delete[] pReleaseKeys;
    FreePnextChain(pNext);
    sType = in_struct->sType;
    acquireCount = in_struct->acquireCount;
    pAcquireSyncs = nullptr;
    pAcquireKeys = nullptr;
    pAcquireTimeouts = nullptr;
    releaseCount = in_struct->releaseCount;
    pReleaseSyncs = nullptr;
    pReleaseKeys = nullptr;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);
    if (acquireCount && in_struct->pAcquireSyncs) {
        pAcquireSyncs = new VkDeviceMemory[acquireCount];
        for (uint32_t i = 0; i < acquireCount; ++i) {
            pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
        }
    }

    if (in_struct->pAcquireKeys) {
        pAcquireKeys = new uint64_t[in_struct->acquireCount];
        memcpy((void*)pAcquireKeys, (void*)in_struct->pAcquireKeys, sizeof(uint64_t) * in_struct->acquireCount);
    }

    if (in_struct->pAcquireTimeouts) {
        pAcquireTimeouts = new uint32_t[in_struct->acquireCount];
        memcpy((void*)pAcquireTimeouts, (void*)in_struct->pAcquireTimeouts, sizeof(uint32_t) * in_struct->acquireCount);
    }
    if (releaseCount && in_struct->pReleaseSyncs) {
        pReleaseSyncs = new VkDeviceMemory[releaseCount];
        for (uint32_t i = 0; i < releaseCount; ++i) {
            pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
        }
    }

    if (in_struct->pReleaseKeys) {
        pReleaseKeys = new uint64_t[in_struct->releaseCount];
        memcpy((void*)pReleaseKeys, (void*)in_struct->pReleaseKeys, sizeof(uint64_t) * in_struct->releaseCount);
    }
}

void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* copy_src,
                                                             [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    acquireCount = copy_src->acquireCount;
    pAcquireSyncs = nullptr;
    pAcquireKeys = nullptr;
    pAcquireTimeouts = nullptr;
    releaseCount = copy_src->releaseCount;
    pReleaseSyncs = nullptr;
    pReleaseKeys = nullptr;
    pNext = SafePnextCopy(copy_src->pNext);
    if (acquireCount && copy_src->pAcquireSyncs) {
        pAcquireSyncs = new VkDeviceMemory[acquireCount];
        for (uint32_t i = 0; i < acquireCount; ++i) {
            pAcquireSyncs[i] = copy_src->pAcquireSyncs[i];
        }
    }

    if (copy_src->pAcquireKeys) {
        pAcquireKeys = new uint64_t[copy_src->acquireCount];
        memcpy((void*)pAcquireKeys, (void*)copy_src->pAcquireKeys, sizeof(uint64_t) * copy_src->acquireCount);
    }

    if (copy_src->pAcquireTimeouts) {
        pAcquireTimeouts = new uint32_t[copy_src->acquireCount];
        memcpy((void*)pAcquireTimeouts, (void*)copy_src->pAcquireTimeouts, sizeof(uint32_t) * copy_src->acquireCount);
    }
    if (releaseCount && copy_src->pReleaseSyncs) {
        pReleaseSyncs = new VkDeviceMemory[releaseCount];
        for (uint32_t i = 0; i < releaseCount; ++i) {
            pReleaseSyncs[i] = copy_src->pReleaseSyncs[i];
        }
    }

    if (copy_src->pReleaseKeys) {
        pReleaseKeys = new uint64_t[copy_src->releaseCount];
        memcpy((void*)pReleaseKeys, (void*)copy_src->pReleaseKeys, sizeof(uint64_t) * copy_src->releaseCount);
    }
}

safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR(
    const VkImportSemaphoreWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : sType(in_struct->sType),
      semaphore(in_struct->semaphore),
      flags(in_struct->flags),
      handleType(in_struct->handleType),
      handle(in_struct->handle),
      name(in_struct->name) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
}

safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR()
    : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR),
      pNext(nullptr),
      semaphore(),
      flags(),
      handleType(),
      handle(),
      name() {}

safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR(
    const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src) {
    sType = copy_src.sType;
    semaphore = copy_src.semaphore;
    flags = copy_src.flags;
    handleType = copy_src.handleType;
    handle = copy_src.handle;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);
}

safe_VkImportSemaphoreWin32HandleInfoKHR& safe_VkImportSemaphoreWin32HandleInfoKHR::operator=(
    const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src) {
    if (&copy_src == this) return *this;

    FreePnextChain(pNext);

    sType = copy_src.sType;
    semaphore = copy_src.semaphore;
    flags = copy_src.flags;
    handleType = copy_src.handleType;
    handle = copy_src.handle;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);

    return *this;
}

safe_VkImportSemaphoreWin32HandleInfoKHR::~safe_VkImportSemaphoreWin32HandleInfoKHR() { FreePnextChain(pNext); }

void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state) {
    FreePnextChain(pNext);
    sType = in_struct->sType;
    semaphore = in_struct->semaphore;
    flags = in_struct->flags;
    handleType = in_struct->handleType;
    handle = in_struct->handle;
    name = in_struct->name;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);
}

void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* copy_src,
                                                          [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    semaphore = copy_src->semaphore;
    flags = copy_src->flags;
    handleType = copy_src->handleType;
    handle = copy_src->handle;
    name = copy_src->name;
    pNext = SafePnextCopy(copy_src->pNext);
}

safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR(
    const VkExportSemaphoreWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
    if (in_struct->pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
    }
}

safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR()
    : sType(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {}

safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR(
    const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src) {
    sType = copy_src.sType;
    pAttributes = nullptr;
    dwAccess = copy_src.dwAccess;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);

    if (copy_src.pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
    }
}

safe_VkExportSemaphoreWin32HandleInfoKHR& safe_VkExportSemaphoreWin32HandleInfoKHR::operator=(
    const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src) {
    if (&copy_src == this) return *this;

    if (pAttributes) delete pAttributes;
    FreePnextChain(pNext);

    sType = copy_src.sType;
    pAttributes = nullptr;
    dwAccess = copy_src.dwAccess;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);

    if (copy_src.pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
    }

    return *this;
}

safe_VkExportSemaphoreWin32HandleInfoKHR::~safe_VkExportSemaphoreWin32HandleInfoKHR() {
    if (pAttributes) delete pAttributes;
    FreePnextChain(pNext);
}

void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state) {
    if (pAttributes) delete pAttributes;
    FreePnextChain(pNext);
    sType = in_struct->sType;
    pAttributes = nullptr;
    dwAccess = in_struct->dwAccess;
    name = in_struct->name;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);

    if (in_struct->pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
    }
}

void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* copy_src,
                                                          [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    pAttributes = nullptr;
    dwAccess = copy_src->dwAccess;
    name = copy_src->name;
    pNext = SafePnextCopy(copy_src->pNext);

    if (copy_src->pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes);
    }
}

safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : sType(in_struct->sType),
      waitSemaphoreValuesCount(in_struct->waitSemaphoreValuesCount),
      pWaitSemaphoreValues(nullptr),
      signalSemaphoreValuesCount(in_struct->signalSemaphoreValuesCount),
      pSignalSemaphoreValues(nullptr) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
    if (in_struct->pWaitSemaphoreValues) {
        pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount];
        memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues,
               sizeof(uint64_t) * in_struct->waitSemaphoreValuesCount);
    }

    if (in_struct->pSignalSemaphoreValues) {
        pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount];
        memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues,
               sizeof(uint64_t) * in_struct->signalSemaphoreValuesCount);
    }
}

safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR()
    : sType(VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR),
      pNext(nullptr),
      waitSemaphoreValuesCount(),
      pWaitSemaphoreValues(nullptr),
      signalSemaphoreValuesCount(),
      pSignalSemaphoreValues(nullptr) {}

safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& copy_src) {
    sType = copy_src.sType;
    waitSemaphoreValuesCount = copy_src.waitSemaphoreValuesCount;
    pWaitSemaphoreValues = nullptr;
    signalSemaphoreValuesCount = copy_src.signalSemaphoreValuesCount;
    pSignalSemaphoreValues = nullptr;
    pNext = SafePnextCopy(copy_src.pNext);

    if (copy_src.pWaitSemaphoreValues) {
        pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValuesCount];
        memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues,
               sizeof(uint64_t) * copy_src.waitSemaphoreValuesCount);
    }

    if (copy_src.pSignalSemaphoreValues) {
        pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValuesCount];
        memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues,
               sizeof(uint64_t) * copy_src.signalSemaphoreValuesCount);
    }
}

safe_VkD3D12FenceSubmitInfoKHR& safe_VkD3D12FenceSubmitInfoKHR::operator=(const safe_VkD3D12FenceSubmitInfoKHR& copy_src) {
    if (&copy_src == this) return *this;

    if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues;
    if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues;
    FreePnextChain(pNext);

    sType = copy_src.sType;
    waitSemaphoreValuesCount = copy_src.waitSemaphoreValuesCount;
    pWaitSemaphoreValues = nullptr;
    signalSemaphoreValuesCount = copy_src.signalSemaphoreValuesCount;
    pSignalSemaphoreValues = nullptr;
    pNext = SafePnextCopy(copy_src.pNext);

    if (copy_src.pWaitSemaphoreValues) {
        pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValuesCount];
        memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues,
               sizeof(uint64_t) * copy_src.waitSemaphoreValuesCount);
    }

    if (copy_src.pSignalSemaphoreValues) {
        pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValuesCount];
        memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues,
               sizeof(uint64_t) * copy_src.signalSemaphoreValuesCount);
    }

    return *this;
}

safe_VkD3D12FenceSubmitInfoKHR::~safe_VkD3D12FenceSubmitInfoKHR() {
    if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues;
    if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues;
    FreePnextChain(pNext);
}

void safe_VkD3D12FenceSubmitInfoKHR::initialize(const VkD3D12FenceSubmitInfoKHR* in_struct,
                                                [[maybe_unused]] PNextCopyState* copy_state) {
    if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues;
    if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues;
    FreePnextChain(pNext);
    sType = in_struct->sType;
    waitSemaphoreValuesCount = in_struct->waitSemaphoreValuesCount;
    pWaitSemaphoreValues = nullptr;
    signalSemaphoreValuesCount = in_struct->signalSemaphoreValuesCount;
    pSignalSemaphoreValues = nullptr;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);

    if (in_struct->pWaitSemaphoreValues) {
        pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount];
        memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues,
               sizeof(uint64_t) * in_struct->waitSemaphoreValuesCount);
    }

    if (in_struct->pSignalSemaphoreValues) {
        pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount];
        memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues,
               sizeof(uint64_t) * in_struct->signalSemaphoreValuesCount);
    }
}

void safe_VkD3D12FenceSubmitInfoKHR::initialize(const safe_VkD3D12FenceSubmitInfoKHR* copy_src,
                                                [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    waitSemaphoreValuesCount = copy_src->waitSemaphoreValuesCount;
    pWaitSemaphoreValues = nullptr;
    signalSemaphoreValuesCount = copy_src->signalSemaphoreValuesCount;
    pSignalSemaphoreValues = nullptr;
    pNext = SafePnextCopy(copy_src->pNext);

    if (copy_src->pWaitSemaphoreValues) {
        pWaitSemaphoreValues = new uint64_t[copy_src->waitSemaphoreValuesCount];
        memcpy((void*)pWaitSemaphoreValues, (void*)copy_src->pWaitSemaphoreValues,
               sizeof(uint64_t) * copy_src->waitSemaphoreValuesCount);
    }

    if (copy_src->pSignalSemaphoreValues) {
        pSignalSemaphoreValues = new uint64_t[copy_src->signalSemaphoreValuesCount];
        memcpy((void*)pSignalSemaphoreValues, (void*)copy_src->pSignalSemaphoreValues,
               sizeof(uint64_t) * copy_src->signalSemaphoreValuesCount);
    }
}

safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : sType(in_struct->sType), semaphore(in_struct->semaphore), handleType(in_struct->handleType) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
}

safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR()
    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), semaphore(), handleType() {}

safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(
    const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src) {
    sType = copy_src.sType;
    semaphore = copy_src.semaphore;
    handleType = copy_src.handleType;
    pNext = SafePnextCopy(copy_src.pNext);
}

safe_VkSemaphoreGetWin32HandleInfoKHR& safe_VkSemaphoreGetWin32HandleInfoKHR::operator=(
    const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src) {
    if (&copy_src == this) return *this;

    FreePnextChain(pNext);

    sType = copy_src.sType;
    semaphore = copy_src.semaphore;
    handleType = copy_src.handleType;
    pNext = SafePnextCopy(copy_src.pNext);

    return *this;
}

safe_VkSemaphoreGetWin32HandleInfoKHR::~safe_VkSemaphoreGetWin32HandleInfoKHR() { FreePnextChain(pNext); }

void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) {
    FreePnextChain(pNext);
    sType = in_struct->sType;
    semaphore = in_struct->semaphore;
    handleType = in_struct->handleType;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);
}

void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    semaphore = copy_src->semaphore;
    handleType = copy_src->handleType;
    pNext = SafePnextCopy(copy_src->pNext);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct,
                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR()
    : … { … }

safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& copy_src) { … }

safe_VkImportSemaphoreFdInfoKHR& safe_VkImportSemaphoreFdInfoKHR::operator=(const safe_VkImportSemaphoreFdInfoKHR& copy_src) { … }

safe_VkImportSemaphoreFdInfoKHR::~safe_VkImportSemaphoreFdInfoKHR() { … }

void safe_VkImportSemaphoreFdInfoKHR::initialize(const VkImportSemaphoreFdInfoKHR* in_struct,
                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkImportSemaphoreFdInfoKHR::initialize(const safe_VkImportSemaphoreFdInfoKHR* copy_src,
                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR()
    : … { … }

safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& copy_src) { … }

safe_VkSemaphoreGetFdInfoKHR& safe_VkSemaphoreGetFdInfoKHR::operator=(const safe_VkSemaphoreGetFdInfoKHR& copy_src) { … }

safe_VkSemaphoreGetFdInfoKHR::~safe_VkSemaphoreGetFdInfoKHR() { … }

void safe_VkSemaphoreGetFdInfoKHR::initialize(const VkSemaphoreGetFdInfoKHR* in_struct,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkSemaphoreGetFdInfoKHR::initialize(const safe_VkSemaphoreGetFdInfoKHR* copy_src,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(
    const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR()
    : … { … }

safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(
    const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) { … }

safe_VkPhysicalDevicePushDescriptorPropertiesKHR& safe_VkPhysicalDevicePushDescriptorPropertiesKHR::operator=(
    const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) { … }

safe_VkPhysicalDevicePushDescriptorPropertiesKHR::~safe_VkPhysicalDevicePushDescriptorPropertiesKHR() { … }

void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state)
    : … { … }

safe_VkPresentRegionKHR::safe_VkPresentRegionKHR() : … { … }

safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& copy_src) { … }

safe_VkPresentRegionKHR& safe_VkPresentRegionKHR::operator=(const safe_VkPresentRegionKHR& copy_src) { … }

safe_VkPresentRegionKHR::~safe_VkPresentRegionKHR() { … }

void safe_VkPresentRegionKHR::initialize(const VkPresentRegionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPresentRegionKHR::initialize(const safe_VkPresentRegionKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct,
                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR()
    : … { … }

safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& copy_src) { … }

safe_VkPresentRegionsKHR& safe_VkPresentRegionsKHR::operator=(const safe_VkPresentRegionsKHR& copy_src) { … }

safe_VkPresentRegionsKHR::~safe_VkPresentRegionsKHR() { … }

void safe_VkPresentRegionsKHR::initialize(const VkPresentRegionsKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPresentRegionsKHR::initialize(const safe_VkPresentRegionsKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR(
    const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR()
    : … { … }

safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR(
    const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src) { … }

safe_VkSharedPresentSurfaceCapabilitiesKHR& safe_VkSharedPresentSurfaceCapabilitiesKHR::operator=(
    const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src) { … }

safe_VkSharedPresentSurfaceCapabilitiesKHR::~safe_VkSharedPresentSurfaceCapabilitiesKHR() { … }

void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* copy_src,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }
#ifdef VK_USE_PLATFORM_WIN32_KHR

safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : sType(in_struct->sType),
      fence(in_struct->fence),
      flags(in_struct->flags),
      handleType(in_struct->handleType),
      handle(in_struct->handle),
      name(in_struct->name) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
}

safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR()
    : sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR),
      pNext(nullptr),
      fence(),
      flags(),
      handleType(),
      handle(),
      name() {}

safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& copy_src) {
    sType = copy_src.sType;
    fence = copy_src.fence;
    flags = copy_src.flags;
    handleType = copy_src.handleType;
    handle = copy_src.handle;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);
}

safe_VkImportFenceWin32HandleInfoKHR& safe_VkImportFenceWin32HandleInfoKHR::operator=(
    const safe_VkImportFenceWin32HandleInfoKHR& copy_src) {
    if (&copy_src == this) return *this;

    FreePnextChain(pNext);

    sType = copy_src.sType;
    fence = copy_src.fence;
    flags = copy_src.flags;
    handleType = copy_src.handleType;
    handle = copy_src.handle;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);

    return *this;
}

safe_VkImportFenceWin32HandleInfoKHR::~safe_VkImportFenceWin32HandleInfoKHR() { FreePnextChain(pNext); }

void safe_VkImportFenceWin32HandleInfoKHR::initialize(const VkImportFenceWin32HandleInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) {
    FreePnextChain(pNext);
    sType = in_struct->sType;
    fence = in_struct->fence;
    flags = in_struct->flags;
    handleType = in_struct->handleType;
    handle = in_struct->handle;
    name = in_struct->name;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);
}

void safe_VkImportFenceWin32HandleInfoKHR::initialize(const safe_VkImportFenceWin32HandleInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    fence = copy_src->fence;
    flags = copy_src->flags;
    handleType = copy_src->handleType;
    handle = copy_src->handle;
    name = copy_src->name;
    pNext = SafePnextCopy(copy_src->pNext);
}

safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
    if (in_struct->pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
    }
}

safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR()
    : sType(VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {}

safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& copy_src) {
    sType = copy_src.sType;
    pAttributes = nullptr;
    dwAccess = copy_src.dwAccess;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);

    if (copy_src.pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
    }
}

safe_VkExportFenceWin32HandleInfoKHR& safe_VkExportFenceWin32HandleInfoKHR::operator=(
    const safe_VkExportFenceWin32HandleInfoKHR& copy_src) {
    if (&copy_src == this) return *this;

    if (pAttributes) delete pAttributes;
    FreePnextChain(pNext);

    sType = copy_src.sType;
    pAttributes = nullptr;
    dwAccess = copy_src.dwAccess;
    name = copy_src.name;
    pNext = SafePnextCopy(copy_src.pNext);

    if (copy_src.pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
    }

    return *this;
}

safe_VkExportFenceWin32HandleInfoKHR::~safe_VkExportFenceWin32HandleInfoKHR() {
    if (pAttributes) delete pAttributes;
    FreePnextChain(pNext);
}

void safe_VkExportFenceWin32HandleInfoKHR::initialize(const VkExportFenceWin32HandleInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) {
    if (pAttributes) delete pAttributes;
    FreePnextChain(pNext);
    sType = in_struct->sType;
    pAttributes = nullptr;
    dwAccess = in_struct->dwAccess;
    name = in_struct->name;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);

    if (in_struct->pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
    }
}

void safe_VkExportFenceWin32HandleInfoKHR::initialize(const safe_VkExportFenceWin32HandleInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    pAttributes = nullptr;
    dwAccess = copy_src->dwAccess;
    name = copy_src->name;
    pNext = SafePnextCopy(copy_src->pNext);

    if (copy_src->pAttributes) {
        pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes);
    }
}

safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct,
                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : sType(in_struct->sType), fence(in_struct->fence), handleType(in_struct->handleType) {
    if (copy_pnext) {
        pNext = SafePnextCopy(in_struct->pNext, copy_state);
    }
}

safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR()
    : sType(VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), fence(), handleType() {}

safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& copy_src) {
    sType = copy_src.sType;
    fence = copy_src.fence;
    handleType = copy_src.handleType;
    pNext = SafePnextCopy(copy_src.pNext);
}

safe_VkFenceGetWin32HandleInfoKHR& safe_VkFenceGetWin32HandleInfoKHR::operator=(const safe_VkFenceGetWin32HandleInfoKHR& copy_src) {
    if (&copy_src == this) return *this;

    FreePnextChain(pNext);

    sType = copy_src.sType;
    fence = copy_src.fence;
    handleType = copy_src.handleType;
    pNext = SafePnextCopy(copy_src.pNext);

    return *this;
}

safe_VkFenceGetWin32HandleInfoKHR::~safe_VkFenceGetWin32HandleInfoKHR() { FreePnextChain(pNext); }

void safe_VkFenceGetWin32HandleInfoKHR::initialize(const VkFenceGetWin32HandleInfoKHR* in_struct,
                                                   [[maybe_unused]] PNextCopyState* copy_state) {
    FreePnextChain(pNext);
    sType = in_struct->sType;
    fence = in_struct->fence;
    handleType = in_struct->handleType;
    pNext = SafePnextCopy(in_struct->pNext, copy_state);
}

void safe_VkFenceGetWin32HandleInfoKHR::initialize(const safe_VkFenceGetWin32HandleInfoKHR* copy_src,
                                                   [[maybe_unused]] PNextCopyState* copy_state) {
    sType = copy_src->sType;
    fence = copy_src->fence;
    handleType = copy_src->handleType;
    pNext = SafePnextCopy(copy_src->pNext);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct,
                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR()
    : … { … }

safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& copy_src) { … }

safe_VkImportFenceFdInfoKHR& safe_VkImportFenceFdInfoKHR::operator=(const safe_VkImportFenceFdInfoKHR& copy_src) { … }

safe_VkImportFenceFdInfoKHR::~safe_VkImportFenceFdInfoKHR() { … }

void safe_VkImportFenceFdInfoKHR::initialize(const VkImportFenceFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkImportFenceFdInfoKHR::initialize(const safe_VkImportFenceFdInfoKHR* copy_src,
                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct,
                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR()
    : … { … }

safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& copy_src) { … }

safe_VkFenceGetFdInfoKHR& safe_VkFenceGetFdInfoKHR::operator=(const safe_VkFenceGetFdInfoKHR& copy_src) { … }

safe_VkFenceGetFdInfoKHR::~safe_VkFenceGetFdInfoKHR() { … }

void safe_VkFenceGetFdInfoKHR::initialize(const VkFenceGetFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkFenceGetFdInfoKHR::initialize(const safe_VkFenceGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(
    const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR()
    : … { … }

safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(
    const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::operator=(
    const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::~safe_VkPhysicalDevicePerformanceQueryFeaturesKHR() { … }

void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR* copy_src,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(
    const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR()
    : … { … }

safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(
    const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src) { … }

safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::operator=(
    const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src) { … }

safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::~safe_VkPhysicalDevicePerformanceQueryPropertiesKHR() { … }

void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct,
                                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize(
    const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR()
    : … { … }

safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR(const safe_VkPerformanceCounterKHR& copy_src) { … }

safe_VkPerformanceCounterKHR& safe_VkPerformanceCounterKHR::operator=(const safe_VkPerformanceCounterKHR& copy_src) { … }

safe_VkPerformanceCounterKHR::~safe_VkPerformanceCounterKHR() { … }

void safe_VkPerformanceCounterKHR::initialize(const VkPerformanceCounterKHR* in_struct,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPerformanceCounterKHR::initialize(const safe_VkPerformanceCounterKHR* copy_src,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR(
    const VkPerformanceCounterDescriptionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR()
    : … { … }

safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR(
    const safe_VkPerformanceCounterDescriptionKHR& copy_src) { … }

safe_VkPerformanceCounterDescriptionKHR& safe_VkPerformanceCounterDescriptionKHR::operator=(
    const safe_VkPerformanceCounterDescriptionKHR& copy_src) { … }

safe_VkPerformanceCounterDescriptionKHR::~safe_VkPerformanceCounterDescriptionKHR() { … }

void safe_VkPerformanceCounterDescriptionKHR::initialize(const VkPerformanceCounterDescriptionKHR* in_struct,
                                                         [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPerformanceCounterDescriptionKHR::initialize(const safe_VkPerformanceCounterDescriptionKHR* copy_src,
                                                         [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR(
    const VkQueryPoolPerformanceCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR()
    : … { … }

safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR(
    const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src) { … }

safe_VkQueryPoolPerformanceCreateInfoKHR& safe_VkQueryPoolPerformanceCreateInfoKHR::operator=(
    const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src) { … }

safe_VkQueryPoolPerformanceCreateInfoKHR::~safe_VkQueryPoolPerformanceCreateInfoKHR() { … }

void safe_VkQueryPoolPerformanceCreateInfoKHR::initialize(const VkQueryPoolPerformanceCreateInfoKHR* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkQueryPoolPerformanceCreateInfoKHR::initialize(const safe_VkQueryPoolPerformanceCreateInfoKHR* copy_src,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* in_struct,
                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR()
    : … { … }

safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR(const safe_VkAcquireProfilingLockInfoKHR& copy_src) { … }

safe_VkAcquireProfilingLockInfoKHR& safe_VkAcquireProfilingLockInfoKHR::operator=(
    const safe_VkAcquireProfilingLockInfoKHR& copy_src) { … }

safe_VkAcquireProfilingLockInfoKHR::~safe_VkAcquireProfilingLockInfoKHR() { … }

void safe_VkAcquireProfilingLockInfoKHR::initialize(const VkAcquireProfilingLockInfoKHR* in_struct,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkAcquireProfilingLockInfoKHR::initialize(const safe_VkAcquireProfilingLockInfoKHR* copy_src,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR()
    : … { … }

safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src) { … }

safe_VkPerformanceQuerySubmitInfoKHR& safe_VkPerformanceQuerySubmitInfoKHR::operator=(
    const safe_VkPerformanceQuerySubmitInfoKHR& copy_src) { … }

safe_VkPerformanceQuerySubmitInfoKHR::~safe_VkPerformanceQuerySubmitInfoKHR() { … }

void safe_VkPerformanceQuerySubmitInfoKHR::initialize(const VkPerformanceQuerySubmitInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPerformanceQuerySubmitInfoKHR::initialize(const safe_VkPerformanceQuerySubmitInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR()
    : … { … }

safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src) { … }

safe_VkPhysicalDeviceSurfaceInfo2KHR& safe_VkPhysicalDeviceSurfaceInfo2KHR::operator=(
    const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src) { … }

safe_VkPhysicalDeviceSurfaceInfo2KHR::~safe_VkPhysicalDeviceSurfaceInfo2KHR() { … }

void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR()
    : … { … }

safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& copy_src) { … }

safe_VkSurfaceCapabilities2KHR& safe_VkSurfaceCapabilities2KHR::operator=(const safe_VkSurfaceCapabilities2KHR& copy_src) { … }

safe_VkSurfaceCapabilities2KHR::~safe_VkSurfaceCapabilities2KHR() { … }

void safe_VkSurfaceCapabilities2KHR::initialize(const VkSurfaceCapabilities2KHR* in_struct,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkSurfaceCapabilities2KHR::initialize(const safe_VkSurfaceCapabilities2KHR* copy_src,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct,
                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR()
    : … { … }

safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& copy_src) { … }

safe_VkSurfaceFormat2KHR& safe_VkSurfaceFormat2KHR::operator=(const safe_VkSurfaceFormat2KHR& copy_src) { … }

safe_VkSurfaceFormat2KHR::~safe_VkSurfaceFormat2KHR() { … }

void safe_VkSurfaceFormat2KHR::initialize(const VkSurfaceFormat2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkSurfaceFormat2KHR::initialize(const safe_VkSurfaceFormat2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR() : … { … }

safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& copy_src) { … }

safe_VkDisplayProperties2KHR& safe_VkDisplayProperties2KHR::operator=(const safe_VkDisplayProperties2KHR& copy_src) { … }

safe_VkDisplayProperties2KHR::~safe_VkDisplayProperties2KHR() { … }

void safe_VkDisplayProperties2KHR::initialize(const VkDisplayProperties2KHR* in_struct,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDisplayProperties2KHR::initialize(const safe_VkDisplayProperties2KHR* copy_src,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct,
                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR()
    : … { … }

safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& copy_src) { … }

safe_VkDisplayPlaneProperties2KHR& safe_VkDisplayPlaneProperties2KHR::operator=(const safe_VkDisplayPlaneProperties2KHR& copy_src) { … }

safe_VkDisplayPlaneProperties2KHR::~safe_VkDisplayPlaneProperties2KHR() { … }

void safe_VkDisplayPlaneProperties2KHR::initialize(const VkDisplayPlaneProperties2KHR* in_struct,
                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDisplayPlaneProperties2KHR::initialize(const safe_VkDisplayPlaneProperties2KHR* copy_src,
                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR()
    : … { … }

safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& copy_src) { … }

safe_VkDisplayModeProperties2KHR& safe_VkDisplayModeProperties2KHR::operator=(const safe_VkDisplayModeProperties2KHR& copy_src) { … }

safe_VkDisplayModeProperties2KHR::~safe_VkDisplayModeProperties2KHR() { … }

void safe_VkDisplayModeProperties2KHR::initialize(const VkDisplayModeProperties2KHR* in_struct,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDisplayModeProperties2KHR::initialize(const safe_VkDisplayModeProperties2KHR* copy_src,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct,
                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR()
    : … { … }

safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& copy_src) { … }

safe_VkDisplayPlaneInfo2KHR& safe_VkDisplayPlaneInfo2KHR::operator=(const safe_VkDisplayPlaneInfo2KHR& copy_src) { … }

safe_VkDisplayPlaneInfo2KHR::~safe_VkDisplayPlaneInfo2KHR() { … }

void safe_VkDisplayPlaneInfo2KHR::initialize(const VkDisplayPlaneInfo2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDisplayPlaneInfo2KHR::initialize(const safe_VkDisplayPlaneInfo2KHR* copy_src,
                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct,
                                                                         [[maybe_unused]] PNextCopyState* copy_state,
                                                                         bool copy_pnext)
    : … { … }

safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR()
    : … { … }

safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& copy_src) { … }

safe_VkDisplayPlaneCapabilities2KHR& safe_VkDisplayPlaneCapabilities2KHR::operator=(
    const safe_VkDisplayPlaneCapabilities2KHR& copy_src) { … }

safe_VkDisplayPlaneCapabilities2KHR::~safe_VkDisplayPlaneCapabilities2KHR() { … }

void safe_VkDisplayPlaneCapabilities2KHR::initialize(const VkDisplayPlaneCapabilities2KHR* in_struct,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDisplayPlaneCapabilities2KHR::initialize(const safe_VkDisplayPlaneCapabilities2KHR* copy_src,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }
#ifdef VK_ENABLE_BETA_EXTENSIONS

safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
    const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR()
    : … { … }

safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
    const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::operator=(
    const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::~safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR() { … }

void safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::initialize(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::initialize(
    const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
    const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR()
    : … { … }

safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
    const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src) { … }

safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::operator=(
    const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src) { … }

safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::~safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR() { … }

void safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::initialize(
    const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::initialize(
    const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }
#endif  // VK_ENABLE_BETA_EXTENSIONS

safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR(
    const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR(
    const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderClockFeaturesKHR& safe_VkPhysicalDeviceShaderClockFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderClockFeaturesKHR::~safe_VkPhysicalDeviceShaderClockFeaturesKHR() { … }

void safe_VkPhysicalDeviceShaderClockFeaturesKHR::initialize(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceShaderClockFeaturesKHR::initialize(const safe_VkPhysicalDeviceShaderClockFeaturesKHR* copy_src,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR()
    : … { … }

safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR(const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src) { … }

safe_VkVideoDecodeH265ProfileInfoKHR& safe_VkVideoDecodeH265ProfileInfoKHR::operator=(
    const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src) { … }

safe_VkVideoDecodeH265ProfileInfoKHR::~safe_VkVideoDecodeH265ProfileInfoKHR() { … }

void safe_VkVideoDecodeH265ProfileInfoKHR::initialize(const VkVideoDecodeH265ProfileInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH265ProfileInfoKHR::initialize(const safe_VkVideoDecodeH265ProfileInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR()
    : … { … }

safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR(
    const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src) { … }

safe_VkVideoDecodeH265CapabilitiesKHR& safe_VkVideoDecodeH265CapabilitiesKHR::operator=(
    const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src) { … }

safe_VkVideoDecodeH265CapabilitiesKHR::~safe_VkVideoDecodeH265CapabilitiesKHR() { … }

void safe_VkVideoDecodeH265CapabilitiesKHR::initialize(const VkVideoDecodeH265CapabilitiesKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH265CapabilitiesKHR::initialize(const safe_VkVideoDecodeH265CapabilitiesKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR(
    const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR()
    : … { … }

safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR(
    const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src) { … }

safe_VkVideoDecodeH265SessionParametersAddInfoKHR& safe_VkVideoDecodeH265SessionParametersAddInfoKHR::operator=(
    const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src) { … }

safe_VkVideoDecodeH265SessionParametersAddInfoKHR::~safe_VkVideoDecodeH265SessionParametersAddInfoKHR() { … }

void safe_VkVideoDecodeH265SessionParametersAddInfoKHR::initialize(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH265SessionParametersAddInfoKHR::initialize(
    const safe_VkVideoDecodeH265SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(
    const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR()
    : … { … }

safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(
    const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::operator=(
    const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::~safe_VkVideoDecodeH265SessionParametersCreateInfoKHR() { … }

void safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::initialize(
    const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::initialize(
    const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR()
    : … { … }

safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR(const safe_VkVideoDecodeH265PictureInfoKHR& copy_src) { … }

safe_VkVideoDecodeH265PictureInfoKHR& safe_VkVideoDecodeH265PictureInfoKHR::operator=(
    const safe_VkVideoDecodeH265PictureInfoKHR& copy_src) { … }

safe_VkVideoDecodeH265PictureInfoKHR::~safe_VkVideoDecodeH265PictureInfoKHR() { … }

void safe_VkVideoDecodeH265PictureInfoKHR::initialize(const VkVideoDecodeH265PictureInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH265PictureInfoKHR::initialize(const safe_VkVideoDecodeH265PictureInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR()
    : … { … }

safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR(const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src) { … }

safe_VkVideoDecodeH265DpbSlotInfoKHR& safe_VkVideoDecodeH265DpbSlotInfoKHR::operator=(
    const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src) { … }

safe_VkVideoDecodeH265DpbSlotInfoKHR::~safe_VkVideoDecodeH265DpbSlotInfoKHR() { … }

void safe_VkVideoDecodeH265DpbSlotInfoKHR::initialize(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeH265DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH265DpbSlotInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(
    const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR()
    : … { … }

safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(
    const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src) { … }

safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::operator=(
    const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src) { … }

safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::~safe_VkDeviceQueueGlobalPriorityCreateInfoKHR() { … }

void safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::initialize(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR* copy_src,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
    const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::~safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR() { … }

void safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::initialize(
    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR(
    const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR()
    : … { … }

safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR(
    const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src) { … }

safe_VkQueueFamilyGlobalPriorityPropertiesKHR& safe_VkQueueFamilyGlobalPriorityPropertiesKHR::operator=(
    const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src) { … }

safe_VkQueueFamilyGlobalPriorityPropertiesKHR::~safe_VkQueueFamilyGlobalPriorityPropertiesKHR() { … }

void safe_VkQueueFamilyGlobalPriorityPropertiesKHR::initialize(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkQueueFamilyGlobalPriorityPropertiesKHR::initialize(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR* copy_src,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR(
    const VkFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR()
    : … { … }

safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR(
    const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src) { … }

safe_VkFragmentShadingRateAttachmentInfoKHR& safe_VkFragmentShadingRateAttachmentInfoKHR::operator=(
    const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src) { … }

safe_VkFragmentShadingRateAttachmentInfoKHR::~safe_VkFragmentShadingRateAttachmentInfoKHR() { … }

void safe_VkFragmentShadingRateAttachmentInfoKHR::initialize(const VkFragmentShadingRateAttachmentInfoKHR* in_struct,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkFragmentShadingRateAttachmentInfoKHR::initialize(const safe_VkFragmentShadingRateAttachmentInfoKHR* copy_src,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(
    const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR()
    : … { … }

safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(
    const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src) { … }

safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::operator=(
    const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src) { … }

safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::~safe_VkPipelineFragmentShadingRateStateCreateInfoKHR() { … }

void safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::initialize(
    const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::initialize(
    const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
    const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::~safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR() { … }

void safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::initialize(
    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
    const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::operator=(
    const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::~safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR() { … }

void safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::initialize(
    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::initialize(
    const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR(
    const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR()
    : … { … }

safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR(
    const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src) { … }

safe_VkPhysicalDeviceFragmentShadingRateKHR& safe_VkPhysicalDeviceFragmentShadingRateKHR::operator=(
    const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src) { … }

safe_VkPhysicalDeviceFragmentShadingRateKHR::~safe_VkPhysicalDeviceFragmentShadingRateKHR() { … }

void safe_VkPhysicalDeviceFragmentShadingRateKHR::initialize(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceFragmentShadingRateKHR::initialize(const safe_VkPhysicalDeviceFragmentShadingRateKHR* copy_src,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(
    const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(
    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR() { … }

void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::initialize(
    const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR(
    const VkRenderingAttachmentLocationInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR()
    : … { … }

safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR(
    const safe_VkRenderingAttachmentLocationInfoKHR& copy_src) { … }

safe_VkRenderingAttachmentLocationInfoKHR& safe_VkRenderingAttachmentLocationInfoKHR::operator=(
    const safe_VkRenderingAttachmentLocationInfoKHR& copy_src) { … }

safe_VkRenderingAttachmentLocationInfoKHR::~safe_VkRenderingAttachmentLocationInfoKHR() { … }

void safe_VkRenderingAttachmentLocationInfoKHR::initialize(const VkRenderingAttachmentLocationInfoKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkRenderingAttachmentLocationInfoKHR::initialize(const safe_VkRenderingAttachmentLocationInfoKHR* copy_src,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR(
    const VkRenderingInputAttachmentIndexInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR()
    : … { … }

safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR(
    const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src) { … }

safe_VkRenderingInputAttachmentIndexInfoKHR& safe_VkRenderingInputAttachmentIndexInfoKHR::operator=(
    const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src) { … }

safe_VkRenderingInputAttachmentIndexInfoKHR::~safe_VkRenderingInputAttachmentIndexInfoKHR() { … }

void safe_VkRenderingInputAttachmentIndexInfoKHR::initialize(const VkRenderingInputAttachmentIndexInfoKHR* in_struct,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkRenderingInputAttachmentIndexInfoKHR::initialize(const safe_VkRenderingInputAttachmentIndexInfoKHR* copy_src,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(
    const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(
    const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::~safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR() { … }

void safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::initialize(const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct,
                                                                               [[maybe_unused]] PNextCopyState* copy_state,
                                                                               bool copy_pnext)
    : … { … }

safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR()
    : … { … }

safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(
    const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) { … }

safe_VkSurfaceProtectedCapabilitiesKHR& safe_VkSurfaceProtectedCapabilitiesKHR::operator=(
    const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) { … }

safe_VkSurfaceProtectedCapabilitiesKHR::~safe_VkSurfaceProtectedCapabilitiesKHR() { … }

void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct,
                                                        [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src,
                                                        [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR(
    const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR()
    : … { … }

safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR(
    const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePresentWaitFeaturesKHR& safe_VkPhysicalDevicePresentWaitFeaturesKHR::operator=(
    const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePresentWaitFeaturesKHR::~safe_VkPhysicalDevicePresentWaitFeaturesKHR() { … }

void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const safe_VkPhysicalDevicePresentWaitFeaturesKHR* copy_src,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR()
    : … { … }

safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
    const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR&
safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::operator=(
    const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR() { … }

void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize(
    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize(
    const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
                                               bool copy_pnext)
    : … { … }

safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR() : … { … }

safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& copy_src) { … }

safe_VkPipelineInfoKHR& safe_VkPipelineInfoKHR::operator=(const safe_VkPipelineInfoKHR& copy_src) { … }

safe_VkPipelineInfoKHR::~safe_VkPipelineInfoKHR() { … }

void safe_VkPipelineInfoKHR::initialize(const VkPipelineInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineInfoKHR::initialize(const safe_VkPipelineInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct,
                                                                               [[maybe_unused]] PNextCopyState* copy_state,
                                                                               bool copy_pnext)
    : … { … }

safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR()
    : … { … }

safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR(
    const safe_VkPipelineExecutablePropertiesKHR& copy_src) { … }

safe_VkPipelineExecutablePropertiesKHR& safe_VkPipelineExecutablePropertiesKHR::operator=(
    const safe_VkPipelineExecutablePropertiesKHR& copy_src) { … }

safe_VkPipelineExecutablePropertiesKHR::~safe_VkPipelineExecutablePropertiesKHR() { … }

void safe_VkPipelineExecutablePropertiesKHR::initialize(const VkPipelineExecutablePropertiesKHR* in_struct,
                                                        [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineExecutablePropertiesKHR::initialize(const safe_VkPipelineExecutablePropertiesKHR* copy_src,
                                                        [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR()
    : … { … }

safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& copy_src) { … }

safe_VkPipelineExecutableInfoKHR& safe_VkPipelineExecutableInfoKHR::operator=(const safe_VkPipelineExecutableInfoKHR& copy_src) { … }

safe_VkPipelineExecutableInfoKHR::~safe_VkPipelineExecutableInfoKHR() { … }

void safe_VkPipelineExecutableInfoKHR::initialize(const VkPipelineExecutableInfoKHR* in_struct,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineExecutableInfoKHR::initialize(const safe_VkPipelineExecutableInfoKHR* copy_src,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : … { … }

safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR()
    : … { … }

safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR(
    const safe_VkPipelineExecutableStatisticKHR& copy_src) { … }

safe_VkPipelineExecutableStatisticKHR& safe_VkPipelineExecutableStatisticKHR::operator=(
    const safe_VkPipelineExecutableStatisticKHR& copy_src) { … }

safe_VkPipelineExecutableStatisticKHR::~safe_VkPipelineExecutableStatisticKHR() { … }

void safe_VkPipelineExecutableStatisticKHR::initialize(const VkPipelineExecutableStatisticKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineExecutableStatisticKHR::initialize(const safe_VkPipelineExecutableStatisticKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR(
    const VkPipelineExecutableInternalRepresentationKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR()
    : … { … }

safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR(
    const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src) { … }

safe_VkPipelineExecutableInternalRepresentationKHR& safe_VkPipelineExecutableInternalRepresentationKHR::operator=(
    const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src) { … }

safe_VkPipelineExecutableInternalRepresentationKHR::~safe_VkPipelineExecutableInternalRepresentationKHR() { … }

void safe_VkPipelineExecutableInternalRepresentationKHR::initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct,
                                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineExecutableInternalRepresentationKHR::initialize(
    const safe_VkPipelineExecutableInternalRepresentationKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
                                                 bool copy_pnext)
    : … { … }

safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR()
    : … { … }

safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const safe_VkMemoryMapInfoKHR& copy_src) { … }

safe_VkMemoryMapInfoKHR& safe_VkMemoryMapInfoKHR::operator=(const safe_VkMemoryMapInfoKHR& copy_src) { … }

safe_VkMemoryMapInfoKHR::~safe_VkMemoryMapInfoKHR() { … }

void safe_VkMemoryMapInfoKHR::initialize(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkMemoryMapInfoKHR::initialize(const safe_VkMemoryMapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* in_struct,
                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR()
    : … { … }

safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const safe_VkMemoryUnmapInfoKHR& copy_src) { … }

safe_VkMemoryUnmapInfoKHR& safe_VkMemoryUnmapInfoKHR::operator=(const safe_VkMemoryUnmapInfoKHR& copy_src) { … }

safe_VkMemoryUnmapInfoKHR::~safe_VkMemoryUnmapInfoKHR() { … }

void safe_VkMemoryUnmapInfoKHR::initialize(const VkMemoryUnmapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkMemoryUnmapInfoKHR::initialize(const safe_VkMemoryUnmapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct,
                                                                         [[maybe_unused]] PNextCopyState* copy_state,
                                                                         bool copy_pnext)
    : … { … }

safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR()
    : … { … }

safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const safe_VkPipelineLibraryCreateInfoKHR& copy_src) { … }

safe_VkPipelineLibraryCreateInfoKHR& safe_VkPipelineLibraryCreateInfoKHR::operator=(
    const safe_VkPipelineLibraryCreateInfoKHR& copy_src) { … }

safe_VkPipelineLibraryCreateInfoKHR::~safe_VkPipelineLibraryCreateInfoKHR() { … }

void safe_VkPipelineLibraryCreateInfoKHR::initialize(const VkPipelineLibraryCreateInfoKHR* in_struct,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineLibraryCreateInfoKHR::initialize(const safe_VkPipelineLibraryCreateInfoKHR* copy_src,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPresentIdKHR::safe_VkPresentIdKHR(const VkPresentIdKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
                                         bool copy_pnext)
    : … { … }

safe_VkPresentIdKHR::safe_VkPresentIdKHR()
    : … { … }

safe_VkPresentIdKHR::safe_VkPresentIdKHR(const safe_VkPresentIdKHR& copy_src) { … }

safe_VkPresentIdKHR& safe_VkPresentIdKHR::operator=(const safe_VkPresentIdKHR& copy_src) { … }

safe_VkPresentIdKHR::~safe_VkPresentIdKHR() { … }

void safe_VkPresentIdKHR::initialize(const VkPresentIdKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPresentIdKHR::initialize(const safe_VkPresentIdKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR(
    const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR()
    : … { … }

safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR(
    const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePresentIdFeaturesKHR& safe_VkPhysicalDevicePresentIdFeaturesKHR::operator=(
    const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePresentIdFeaturesKHR::~safe_VkPhysicalDevicePresentIdFeaturesKHR() { … }

void safe_VkPhysicalDevicePresentIdFeaturesKHR::initialize(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDevicePresentIdFeaturesKHR::initialize(const safe_VkPhysicalDevicePresentIdFeaturesKHR* copy_src,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* in_struct,
                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR()
    : … { … }

safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR(const safe_VkVideoEncodeInfoKHR& copy_src) { … }

safe_VkVideoEncodeInfoKHR& safe_VkVideoEncodeInfoKHR::operator=(const safe_VkVideoEncodeInfoKHR& copy_src) { … }

safe_VkVideoEncodeInfoKHR::~safe_VkVideoEncodeInfoKHR() { … }

void safe_VkVideoEncodeInfoKHR::initialize(const VkVideoEncodeInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeInfoKHR::initialize(const safe_VkVideoEncodeInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR* in_struct,
                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR()
    : … { … }

safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR(const safe_VkVideoEncodeCapabilitiesKHR& copy_src) { … }

safe_VkVideoEncodeCapabilitiesKHR& safe_VkVideoEncodeCapabilitiesKHR::operator=(const safe_VkVideoEncodeCapabilitiesKHR& copy_src) { … }

safe_VkVideoEncodeCapabilitiesKHR::~safe_VkVideoEncodeCapabilitiesKHR() { … }

void safe_VkVideoEncodeCapabilitiesKHR::initialize(const VkVideoEncodeCapabilitiesKHR* in_struct,
                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeCapabilitiesKHR::initialize(const safe_VkVideoEncodeCapabilitiesKHR* copy_src,
                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR()
    : … { … }

safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
    const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src) { … }

safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::operator=(
    const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src) { … }

safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::~safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR() { … }

void safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::initialize(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::initialize(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* copy_src,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR()
    : … { … }

safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR(const safe_VkVideoEncodeUsageInfoKHR& copy_src) { … }

safe_VkVideoEncodeUsageInfoKHR& safe_VkVideoEncodeUsageInfoKHR::operator=(const safe_VkVideoEncodeUsageInfoKHR& copy_src) { … }

safe_VkVideoEncodeUsageInfoKHR::~safe_VkVideoEncodeUsageInfoKHR() { … }

void safe_VkVideoEncodeUsageInfoKHR::initialize(const VkVideoEncodeUsageInfoKHR* in_struct,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeUsageInfoKHR::initialize(const safe_VkVideoEncodeUsageInfoKHR* copy_src,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR(
    const VkVideoEncodeRateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR()
    : … { … }

safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR(
    const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src) { … }

safe_VkVideoEncodeRateControlLayerInfoKHR& safe_VkVideoEncodeRateControlLayerInfoKHR::operator=(
    const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src) { … }

safe_VkVideoEncodeRateControlLayerInfoKHR::~safe_VkVideoEncodeRateControlLayerInfoKHR() { … }

void safe_VkVideoEncodeRateControlLayerInfoKHR::initialize(const VkVideoEncodeRateControlLayerInfoKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeRateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeRateControlLayerInfoKHR* copy_src,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR()
    : … { … }

safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR(const safe_VkVideoEncodeRateControlInfoKHR& copy_src) { … }

safe_VkVideoEncodeRateControlInfoKHR& safe_VkVideoEncodeRateControlInfoKHR::operator=(
    const safe_VkVideoEncodeRateControlInfoKHR& copy_src) { … }

safe_VkVideoEncodeRateControlInfoKHR::~safe_VkVideoEncodeRateControlInfoKHR() { … }

void safe_VkVideoEncodeRateControlInfoKHR::initialize(const VkVideoEncodeRateControlInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeRateControlInfoKHR::initialize(const safe_VkVideoEncodeRateControlInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(
    const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR()
    : … { … }

safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(
    const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src) { … }

safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::operator=(
    const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src) { … }

safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::~safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR() { … }

void safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::initialize(
    const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::initialize(
    const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR(
    const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR()
    : … { … }

safe_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR(
    const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src) { … }

safe_VkVideoEncodeQualityLevelPropertiesKHR& safe_VkVideoEncodeQualityLevelPropertiesKHR::operator=(
    const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src) { … }

safe_VkVideoEncodeQualityLevelPropertiesKHR::~safe_VkVideoEncodeQualityLevelPropertiesKHR() { … }

void safe_VkVideoEncodeQualityLevelPropertiesKHR::initialize(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeQualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeQualityLevelPropertiesKHR* copy_src,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR(const VkVideoEncodeQualityLevelInfoKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : … { … }

safe_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR()
    : … { … }

safe_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR(
    const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src) { … }

safe_VkVideoEncodeQualityLevelInfoKHR& safe_VkVideoEncodeQualityLevelInfoKHR::operator=(
    const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src) { … }

safe_VkVideoEncodeQualityLevelInfoKHR::~safe_VkVideoEncodeQualityLevelInfoKHR() { … }

void safe_VkVideoEncodeQualityLevelInfoKHR::initialize(const VkVideoEncodeQualityLevelInfoKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeQualityLevelInfoKHR::initialize(const safe_VkVideoEncodeQualityLevelInfoKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR(
    const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR()
    : … { … }

safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR(
    const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src) { … }

safe_VkVideoEncodeSessionParametersGetInfoKHR& safe_VkVideoEncodeSessionParametersGetInfoKHR::operator=(
    const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src) { … }

safe_VkVideoEncodeSessionParametersGetInfoKHR::~safe_VkVideoEncodeSessionParametersGetInfoKHR() { … }

void safe_VkVideoEncodeSessionParametersGetInfoKHR::initialize(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeSessionParametersGetInfoKHR::initialize(const safe_VkVideoEncodeSessionParametersGetInfoKHR* copy_src,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(
    const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR()
    : … { … }

safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(
    const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src) { … }

safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::operator=(
    const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src) { … }

safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeSessionParametersFeedbackInfoKHR() { … }

void safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::initialize(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct,
                                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::initialize(
    const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
    const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR() { … }

void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::initialize(
    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
    const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::operator=(
    const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::~safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR() { … }

void safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::initialize(
    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::initialize(
    const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
    const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR&
safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::
    ~safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR() { … }

void safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::initialize(
    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
    const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
    const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR&
safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::~safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR() { … }

void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize(
    const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
    const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::operator=(
    const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR() { … }

void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize(
    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize(
    const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(
    const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(
    const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::~safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR() { … }

void safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::initialize(
    const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(
    const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(
    const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::~safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR() { … }

void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize(
    const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR(
    const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR(
    const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance5FeaturesKHR& safe_VkPhysicalDeviceMaintenance5FeaturesKHR::operator=(
    const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance5FeaturesKHR::~safe_VkPhysicalDeviceMaintenance5FeaturesKHR() { … }

void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct,
                                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR* copy_src,
                                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR(
    const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR(
    const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance5PropertiesKHR& safe_VkPhysicalDeviceMaintenance5PropertiesKHR::operator=(
    const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance5PropertiesKHR::~safe_VkPhysicalDeviceMaintenance5PropertiesKHR() { … }

void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR* copy_src,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR(const VkRenderingAreaInfoKHR* in_struct,
                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR()
    : … { … }

safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR(const safe_VkRenderingAreaInfoKHR& copy_src) { … }

safe_VkRenderingAreaInfoKHR& safe_VkRenderingAreaInfoKHR::operator=(const safe_VkRenderingAreaInfoKHR& copy_src) { … }

safe_VkRenderingAreaInfoKHR::~safe_VkRenderingAreaInfoKHR() { … }

void safe_VkRenderingAreaInfoKHR::initialize(const VkRenderingAreaInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkRenderingAreaInfoKHR::initialize(const safe_VkRenderingAreaInfoKHR* copy_src,
                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const VkImageSubresource2KHR* in_struct,
                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR()
    : … { … }

safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const safe_VkImageSubresource2KHR& copy_src) { … }

safe_VkImageSubresource2KHR& safe_VkImageSubresource2KHR::operator=(const safe_VkImageSubresource2KHR& copy_src) { … }

safe_VkImageSubresource2KHR::~safe_VkImageSubresource2KHR() { … }

void safe_VkImageSubresource2KHR::initialize(const VkImageSubresource2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkImageSubresource2KHR::initialize(const safe_VkImageSubresource2KHR* copy_src,
                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR()
    : … { … }

safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const safe_VkDeviceImageSubresourceInfoKHR& copy_src) { … }

safe_VkDeviceImageSubresourceInfoKHR& safe_VkDeviceImageSubresourceInfoKHR::operator=(
    const safe_VkDeviceImageSubresourceInfoKHR& copy_src) { … }

safe_VkDeviceImageSubresourceInfoKHR::~safe_VkDeviceImageSubresourceInfoKHR() { … }

void safe_VkDeviceImageSubresourceInfoKHR::initialize(const VkDeviceImageSubresourceInfoKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDeviceImageSubresourceInfoKHR::initialize(const safe_VkDeviceImageSubresourceInfoKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR()
    : … { … }

safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const safe_VkSubresourceLayout2KHR& copy_src) { … }

safe_VkSubresourceLayout2KHR& safe_VkSubresourceLayout2KHR::operator=(const safe_VkSubresourceLayout2KHR& copy_src) { … }

safe_VkSubresourceLayout2KHR::~safe_VkSubresourceLayout2KHR() { … }

void safe_VkSubresourceLayout2KHR::initialize(const VkSubresourceLayout2KHR* in_struct,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkSubresourceLayout2KHR::initialize(const safe_VkSubresourceLayout2KHR* copy_src,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR(
    const VkPipelineCreateFlags2CreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR()
    : … { … }

safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR(
    const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) { … }

safe_VkPipelineCreateFlags2CreateInfoKHR& safe_VkPipelineCreateFlags2CreateInfoKHR::operator=(
    const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) { … }

safe_VkPipelineCreateFlags2CreateInfoKHR::~safe_VkPipelineCreateFlags2CreateInfoKHR() { … }

void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const safe_VkPipelineCreateFlags2CreateInfoKHR* copy_src,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : … { … }

safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR()
    : … { … }

safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR(
    const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) { … }

safe_VkBufferUsageFlags2CreateInfoKHR& safe_VkBufferUsageFlags2CreateInfoKHR::operator=(
    const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) { … }

safe_VkBufferUsageFlags2CreateInfoKHR::~safe_VkBufferUsageFlags2CreateInfoKHR() { … }

void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const safe_VkBufferUsageFlags2CreateInfoKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
    const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::~safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR() { … }

void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize(
    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(
    const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR()
    : … { … }

safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(
    const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::operator=(
    const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src) { … }

safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::~safe_VkPhysicalDevicePipelineBinaryFeaturesKHR() { … }

void safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::initialize(const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::initialize(const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR* copy_src,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(
    const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR()
    : … { … }

safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(
    const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src) { … }

safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::operator=(
    const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src) { … }

safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::~safe_VkPhysicalDevicePipelineBinaryPropertiesKHR() { … }

void safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::initialize(const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::initialize(const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR* copy_src,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR(
    const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR()
    : … { … }

safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR(
    const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src) { … }

safe_VkDevicePipelineBinaryInternalCacheControlKHR& safe_VkDevicePipelineBinaryInternalCacheControlKHR::operator=(
    const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src) { … }

safe_VkDevicePipelineBinaryInternalCacheControlKHR::~safe_VkDevicePipelineBinaryInternalCacheControlKHR() { … }

void safe_VkDevicePipelineBinaryInternalCacheControlKHR::initialize(const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct,
                                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDevicePipelineBinaryInternalCacheControlKHR::initialize(
    const safe_VkDevicePipelineBinaryInternalCacheControlKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR(const VkPipelineBinaryKeyKHR* in_struct,
                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR()
    : … { … }

safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR(const safe_VkPipelineBinaryKeyKHR& copy_src) { … }

safe_VkPipelineBinaryKeyKHR& safe_VkPipelineBinaryKeyKHR::operator=(const safe_VkPipelineBinaryKeyKHR& copy_src) { … }

safe_VkPipelineBinaryKeyKHR::~safe_VkPipelineBinaryKeyKHR() { … }

void safe_VkPipelineBinaryKeyKHR::initialize(const VkPipelineBinaryKeyKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineBinaryKeyKHR::initialize(const safe_VkPipelineBinaryKeyKHR* copy_src,
                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR(const VkPipelineBinaryDataKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state)
    : … { … }

safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR() : … { … }

safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR(const safe_VkPipelineBinaryDataKHR& copy_src) { … }

safe_VkPipelineBinaryDataKHR& safe_VkPipelineBinaryDataKHR::operator=(const safe_VkPipelineBinaryDataKHR& copy_src) { … }

safe_VkPipelineBinaryDataKHR::~safe_VkPipelineBinaryDataKHR() { … }

void safe_VkPipelineBinaryDataKHR::initialize(const VkPipelineBinaryDataKHR* in_struct,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineBinaryDataKHR::initialize(const safe_VkPipelineBinaryDataKHR* copy_src,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR(const VkPipelineBinaryKeysAndDataKHR* in_struct,
                                                                         [[maybe_unused]] PNextCopyState* copy_state)
    : … { … }

safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR()
    : … { … }

safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR(const safe_VkPipelineBinaryKeysAndDataKHR& copy_src) { … }

safe_VkPipelineBinaryKeysAndDataKHR& safe_VkPipelineBinaryKeysAndDataKHR::operator=(
    const safe_VkPipelineBinaryKeysAndDataKHR& copy_src) { … }

safe_VkPipelineBinaryKeysAndDataKHR::~safe_VkPipelineBinaryKeysAndDataKHR() { … }

void safe_VkPipelineBinaryKeysAndDataKHR::initialize(const VkPipelineBinaryKeysAndDataKHR* in_struct,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineBinaryKeysAndDataKHR::initialize(const safe_VkPipelineBinaryKeysAndDataKHR* copy_src,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR(const VkPipelineCreateInfoKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR() : … { … }

safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR(const safe_VkPipelineCreateInfoKHR& copy_src) { … }

safe_VkPipelineCreateInfoKHR& safe_VkPipelineCreateInfoKHR::operator=(const safe_VkPipelineCreateInfoKHR& copy_src) { … }

safe_VkPipelineCreateInfoKHR::~safe_VkPipelineCreateInfoKHR() { … }

void safe_VkPipelineCreateInfoKHR::initialize(const VkPipelineCreateInfoKHR* in_struct,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineCreateInfoKHR::initialize(const safe_VkPipelineCreateInfoKHR* copy_src,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR(const VkPipelineBinaryCreateInfoKHR* in_struct,
                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR()
    : … { … }

safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR(const safe_VkPipelineBinaryCreateInfoKHR& copy_src) { … }

safe_VkPipelineBinaryCreateInfoKHR& safe_VkPipelineBinaryCreateInfoKHR::operator=(
    const safe_VkPipelineBinaryCreateInfoKHR& copy_src) { … }

safe_VkPipelineBinaryCreateInfoKHR::~safe_VkPipelineBinaryCreateInfoKHR() { … }

void safe_VkPipelineBinaryCreateInfoKHR::initialize(const VkPipelineBinaryCreateInfoKHR* in_struct,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineBinaryCreateInfoKHR::initialize(const safe_VkPipelineBinaryCreateInfoKHR* copy_src,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR(const VkPipelineBinaryInfoKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR()
    : … { … }

safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR(const safe_VkPipelineBinaryInfoKHR& copy_src) { … }

safe_VkPipelineBinaryInfoKHR& safe_VkPipelineBinaryInfoKHR::operator=(const safe_VkPipelineBinaryInfoKHR& copy_src) { … }

safe_VkPipelineBinaryInfoKHR::~safe_VkPipelineBinaryInfoKHR() { … }

void safe_VkPipelineBinaryInfoKHR::initialize(const VkPipelineBinaryInfoKHR* in_struct,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineBinaryInfoKHR::initialize(const safe_VkPipelineBinaryInfoKHR* copy_src,
                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR(
    const VkReleaseCapturedPipelineDataInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR()
    : … { … }

safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR(
    const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src) { … }

safe_VkReleaseCapturedPipelineDataInfoKHR& safe_VkReleaseCapturedPipelineDataInfoKHR::operator=(
    const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src) { … }

safe_VkReleaseCapturedPipelineDataInfoKHR::~safe_VkReleaseCapturedPipelineDataInfoKHR() { … }

void safe_VkReleaseCapturedPipelineDataInfoKHR::initialize(const VkReleaseCapturedPipelineDataInfoKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkReleaseCapturedPipelineDataInfoKHR::initialize(const safe_VkReleaseCapturedPipelineDataInfoKHR* copy_src,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR(const VkPipelineBinaryDataInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR()
    : … { … }

safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR(const safe_VkPipelineBinaryDataInfoKHR& copy_src) { … }

safe_VkPipelineBinaryDataInfoKHR& safe_VkPipelineBinaryDataInfoKHR::operator=(const safe_VkPipelineBinaryDataInfoKHR& copy_src) { … }

safe_VkPipelineBinaryDataInfoKHR::~safe_VkPipelineBinaryDataInfoKHR() { … }

void safe_VkPipelineBinaryDataInfoKHR::initialize(const VkPipelineBinaryDataInfoKHR* in_struct,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineBinaryDataInfoKHR::initialize(const safe_VkPipelineBinaryDataInfoKHR* copy_src,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR(const VkPipelineBinaryHandlesInfoKHR* in_struct,
                                                                         [[maybe_unused]] PNextCopyState* copy_state,
                                                                         bool copy_pnext)
    : … { … }

safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR()
    : … { … }

safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR(const safe_VkPipelineBinaryHandlesInfoKHR& copy_src) { … }

safe_VkPipelineBinaryHandlesInfoKHR& safe_VkPipelineBinaryHandlesInfoKHR::operator=(
    const safe_VkPipelineBinaryHandlesInfoKHR& copy_src) { … }

safe_VkPipelineBinaryHandlesInfoKHR::~safe_VkPipelineBinaryHandlesInfoKHR() { … }

void safe_VkPipelineBinaryHandlesInfoKHR::initialize(const VkPipelineBinaryHandlesInfoKHR* in_struct,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineBinaryHandlesInfoKHR::initialize(const safe_VkPipelineBinaryHandlesInfoKHR* copy_src,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct,
                                                                             [[maybe_unused]] PNextCopyState* copy_state,
                                                                             bool copy_pnext)
    : … { … }

safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR()
    : … { … }

safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR(
    const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { … }

safe_VkCooperativeMatrixPropertiesKHR& safe_VkCooperativeMatrixPropertiesKHR::operator=(
    const safe_VkCooperativeMatrixPropertiesKHR& copy_src) { … }

safe_VkCooperativeMatrixPropertiesKHR::~safe_VkCooperativeMatrixPropertiesKHR() { … }

void safe_VkCooperativeMatrixPropertiesKHR::initialize(const VkCooperativeMatrixPropertiesKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkCooperativeMatrixPropertiesKHR::initialize(const safe_VkCooperativeMatrixPropertiesKHR* copy_src,
                                                       [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(
    const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(
    const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::~safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() { … }

void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(
    const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(
    const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::operator=(
    const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::~safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() { … }

void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize(
    const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize(
    const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR* in_struct,
                                                                         [[maybe_unused]] PNextCopyState* copy_state,
                                                                         bool copy_pnext)
    : … { … }

safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR()
    : … { … }

safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR(const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src) { … }

safe_VkVideoDecodeAV1ProfileInfoKHR& safe_VkVideoDecodeAV1ProfileInfoKHR::operator=(
    const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src) { … }

safe_VkVideoDecodeAV1ProfileInfoKHR::~safe_VkVideoDecodeAV1ProfileInfoKHR() { … }

void safe_VkVideoDecodeAV1ProfileInfoKHR::initialize(const VkVideoDecodeAV1ProfileInfoKHR* in_struct,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeAV1ProfileInfoKHR::initialize(const safe_VkVideoDecodeAV1ProfileInfoKHR* copy_src,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR(const VkVideoDecodeAV1CapabilitiesKHR* in_struct,
                                                                           [[maybe_unused]] PNextCopyState* copy_state,
                                                                           bool copy_pnext)
    : … { … }

safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR()
    : … { … }

safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR(const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src) { … }

safe_VkVideoDecodeAV1CapabilitiesKHR& safe_VkVideoDecodeAV1CapabilitiesKHR::operator=(
    const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src) { … }

safe_VkVideoDecodeAV1CapabilitiesKHR::~safe_VkVideoDecodeAV1CapabilitiesKHR() { … }

void safe_VkVideoDecodeAV1CapabilitiesKHR::initialize(const VkVideoDecodeAV1CapabilitiesKHR* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeAV1CapabilitiesKHR::initialize(const safe_VkVideoDecodeAV1CapabilitiesKHR* copy_src,
                                                      [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(
    const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR()
    : … { … }

safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(
    const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::operator=(
    const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src) { … }

safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::~safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR() { … }

void safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::initialize(
    const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::initialize(
    const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR(const VkVideoDecodeAV1PictureInfoKHR* in_struct,
                                                                         [[maybe_unused]] PNextCopyState* copy_state,
                                                                         bool copy_pnext)
    : … { … }

safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR()
    : … { … }

safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR(const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src) { … }

safe_VkVideoDecodeAV1PictureInfoKHR& safe_VkVideoDecodeAV1PictureInfoKHR::operator=(
    const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src) { … }

safe_VkVideoDecodeAV1PictureInfoKHR::~safe_VkVideoDecodeAV1PictureInfoKHR() { … }

void safe_VkVideoDecodeAV1PictureInfoKHR::initialize(const VkVideoDecodeAV1PictureInfoKHR* in_struct,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeAV1PictureInfoKHR::initialize(const safe_VkVideoDecodeAV1PictureInfoKHR* copy_src,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct,
                                                                         [[maybe_unused]] PNextCopyState* copy_state,
                                                                         bool copy_pnext)
    : … { … }

safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR()
    : … { … }

safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR(const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src) { … }

safe_VkVideoDecodeAV1DpbSlotInfoKHR& safe_VkVideoDecodeAV1DpbSlotInfoKHR::operator=(
    const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src) { … }

safe_VkVideoDecodeAV1DpbSlotInfoKHR::~safe_VkVideoDecodeAV1DpbSlotInfoKHR() { … }

void safe_VkVideoDecodeAV1DpbSlotInfoKHR::initialize(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoDecodeAV1DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeAV1DpbSlotInfoKHR* copy_src,
                                                     [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(
    const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(
    const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::operator=(
    const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR() { … }

void safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::initialize(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::initialize(
    const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR()
    : … { … }

safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR(const safe_VkVideoInlineQueryInfoKHR& copy_src) { … }

safe_VkVideoInlineQueryInfoKHR& safe_VkVideoInlineQueryInfoKHR::operator=(const safe_VkVideoInlineQueryInfoKHR& copy_src) { … }

safe_VkVideoInlineQueryInfoKHR::~safe_VkVideoInlineQueryInfoKHR() { … }

void safe_VkVideoInlineQueryInfoKHR::initialize(const VkVideoInlineQueryInfoKHR* in_struct,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkVideoInlineQueryInfoKHR::initialize(const safe_VkVideoInlineQueryInfoKHR* copy_src,
                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(
    const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(
    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::operator=(
    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR() { … }

void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize(
    const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize(
    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(
    const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR()
    : … { … }

safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(
    const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) { … }

safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::operator=(
    const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) { … }

safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::~safe_VkPipelineVertexInputDivisorStateCreateInfoKHR() { … }

void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize(
    const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize(
    const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(
    const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(
    const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR() { … }

void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize(
    const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(
    const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(
    const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::operator=(
    const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::~safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR() { … }

void safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::initialize(
    const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::initialize(
    const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(
    const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(
    const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::operator=(
    const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::~safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR() { … }

void safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* copy_src,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(
    const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(
    const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::~safe_VkPhysicalDeviceLineRasterizationFeaturesKHR() { … }

void safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::initialize(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(
    const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(
    const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::operator=(
    const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::~safe_VkPhysicalDeviceLineRasterizationPropertiesKHR() { … }

void safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::initialize(
    const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::initialize(
    const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR(
    const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR()
    : … { … }

safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR(
    const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src) { … }

safe_VkPipelineRasterizationLineStateCreateInfoKHR& safe_VkPipelineRasterizationLineStateCreateInfoKHR::operator=(
    const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src) { … }

safe_VkPipelineRasterizationLineStateCreateInfoKHR::~safe_VkPipelineRasterizationLineStateCreateInfoKHR() { … }

void safe_VkPipelineRasterizationLineStateCreateInfoKHR::initialize(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct,
                                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPipelineRasterizationLineStateCreateInfoKHR::initialize(
    const safe_VkPipelineRasterizationLineStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct,
                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR()
    : … { … }

safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const safe_VkCalibratedTimestampInfoKHR& copy_src) { … }

safe_VkCalibratedTimestampInfoKHR& safe_VkCalibratedTimestampInfoKHR::operator=(const safe_VkCalibratedTimestampInfoKHR& copy_src) { … }

safe_VkCalibratedTimestampInfoKHR::~safe_VkCalibratedTimestampInfoKHR() { … }

void safe_VkCalibratedTimestampInfoKHR::initialize(const VkCalibratedTimestampInfoKHR* in_struct,
                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkCalibratedTimestampInfoKHR::initialize(const safe_VkCalibratedTimestampInfoKHR* copy_src,
                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(
    const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(
    const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::~safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR() { … }

void safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::initialize(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct,
                                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR(
    const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR(
    const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance6FeaturesKHR& safe_VkPhysicalDeviceMaintenance6FeaturesKHR::operator=(
    const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance6FeaturesKHR::~safe_VkPhysicalDeviceMaintenance6FeaturesKHR() { … }

void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct,
                                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR* copy_src,
                                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR(
    const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR(
    const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance6PropertiesKHR& safe_VkPhysicalDeviceMaintenance6PropertiesKHR::operator=(
    const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance6PropertiesKHR::~safe_VkPhysicalDeviceMaintenance6PropertiesKHR() { … }

void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR* copy_src,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR(const VkBindMemoryStatusKHR* in_struct,
                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR()
    : … { … }

safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR(const safe_VkBindMemoryStatusKHR& copy_src) { … }

safe_VkBindMemoryStatusKHR& safe_VkBindMemoryStatusKHR::operator=(const safe_VkBindMemoryStatusKHR& copy_src) { … }

safe_VkBindMemoryStatusKHR::~safe_VkBindMemoryStatusKHR() { … }

void safe_VkBindMemoryStatusKHR::initialize(const VkBindMemoryStatusKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkBindMemoryStatusKHR::initialize(const safe_VkBindMemoryStatusKHR* copy_src,
                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const VkBindDescriptorSetsInfoKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR()
    : … { … }

safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const safe_VkBindDescriptorSetsInfoKHR& copy_src) { … }

safe_VkBindDescriptorSetsInfoKHR& safe_VkBindDescriptorSetsInfoKHR::operator=(const safe_VkBindDescriptorSetsInfoKHR& copy_src) { … }

safe_VkBindDescriptorSetsInfoKHR::~safe_VkBindDescriptorSetsInfoKHR() { … }

void safe_VkBindDescriptorSetsInfoKHR::initialize(const VkBindDescriptorSetsInfoKHR* in_struct,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkBindDescriptorSetsInfoKHR::initialize(const safe_VkBindDescriptorSetsInfoKHR* copy_src,
                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR(const VkPushConstantsInfoKHR* in_struct,
                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR()
    : … { … }

safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR(const safe_VkPushConstantsInfoKHR& copy_src) { … }

safe_VkPushConstantsInfoKHR& safe_VkPushConstantsInfoKHR::operator=(const safe_VkPushConstantsInfoKHR& copy_src) { … }

safe_VkPushConstantsInfoKHR::~safe_VkPushConstantsInfoKHR() { … }

void safe_VkPushConstantsInfoKHR::initialize(const VkPushConstantsInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPushConstantsInfoKHR::initialize(const safe_VkPushConstantsInfoKHR* copy_src,
                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const VkPushDescriptorSetInfoKHR* in_struct,
                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR()
    : … { … }

safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const safe_VkPushDescriptorSetInfoKHR& copy_src) { … }

safe_VkPushDescriptorSetInfoKHR& safe_VkPushDescriptorSetInfoKHR::operator=(const safe_VkPushDescriptorSetInfoKHR& copy_src) { … }

safe_VkPushDescriptorSetInfoKHR::~safe_VkPushDescriptorSetInfoKHR() { … }

void safe_VkPushDescriptorSetInfoKHR::initialize(const VkPushDescriptorSetInfoKHR* in_struct,
                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPushDescriptorSetInfoKHR::initialize(const safe_VkPushDescriptorSetInfoKHR* copy_src,
                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR(
    const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR()
    : … { … }

safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR(
    const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src) { … }

safe_VkPushDescriptorSetWithTemplateInfoKHR& safe_VkPushDescriptorSetWithTemplateInfoKHR::operator=(
    const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src) { … }

safe_VkPushDescriptorSetWithTemplateInfoKHR::~safe_VkPushDescriptorSetWithTemplateInfoKHR() { … }

void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const safe_VkPushDescriptorSetWithTemplateInfoKHR* copy_src,
                                                             [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(
    const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(
    const safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR&
safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::
    ~safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR() { … }

void safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::initialize(
    const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceMaintenance7FeaturesKHR::safe_VkPhysicalDeviceMaintenance7FeaturesKHR(
    const VkPhysicalDeviceMaintenance7FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceMaintenance7FeaturesKHR::safe_VkPhysicalDeviceMaintenance7FeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceMaintenance7FeaturesKHR::safe_VkPhysicalDeviceMaintenance7FeaturesKHR(
    const safe_VkPhysicalDeviceMaintenance7FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance7FeaturesKHR& safe_VkPhysicalDeviceMaintenance7FeaturesKHR::operator=(
    const safe_VkPhysicalDeviceMaintenance7FeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance7FeaturesKHR::~safe_VkPhysicalDeviceMaintenance7FeaturesKHR() { … }

void safe_VkPhysicalDeviceMaintenance7FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance7FeaturesKHR* in_struct,
                                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceMaintenance7FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance7FeaturesKHR* copy_src,
                                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceMaintenance7PropertiesKHR::safe_VkPhysicalDeviceMaintenance7PropertiesKHR(
    const VkPhysicalDeviceMaintenance7PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceMaintenance7PropertiesKHR::safe_VkPhysicalDeviceMaintenance7PropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceMaintenance7PropertiesKHR::safe_VkPhysicalDeviceMaintenance7PropertiesKHR(
    const safe_VkPhysicalDeviceMaintenance7PropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance7PropertiesKHR& safe_VkPhysicalDeviceMaintenance7PropertiesKHR::operator=(
    const safe_VkPhysicalDeviceMaintenance7PropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceMaintenance7PropertiesKHR::~safe_VkPhysicalDeviceMaintenance7PropertiesKHR() { … }

void safe_VkPhysicalDeviceMaintenance7PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance7PropertiesKHR* in_struct,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceMaintenance7PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance7PropertiesKHR* copy_src,
                                                                [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceLayeredApiPropertiesKHR::safe_VkPhysicalDeviceLayeredApiPropertiesKHR(
    const VkPhysicalDeviceLayeredApiPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceLayeredApiPropertiesKHR::safe_VkPhysicalDeviceLayeredApiPropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceLayeredApiPropertiesKHR::safe_VkPhysicalDeviceLayeredApiPropertiesKHR(
    const safe_VkPhysicalDeviceLayeredApiPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceLayeredApiPropertiesKHR& safe_VkPhysicalDeviceLayeredApiPropertiesKHR::operator=(
    const safe_VkPhysicalDeviceLayeredApiPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceLayeredApiPropertiesKHR::~safe_VkPhysicalDeviceLayeredApiPropertiesKHR() { … }

void safe_VkPhysicalDeviceLayeredApiPropertiesKHR::initialize(const VkPhysicalDeviceLayeredApiPropertiesKHR* in_struct,
                                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceLayeredApiPropertiesKHR::initialize(const safe_VkPhysicalDeviceLayeredApiPropertiesKHR* copy_src,
                                                              [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::safe_VkPhysicalDeviceLayeredApiPropertiesListKHR(
    const VkPhysicalDeviceLayeredApiPropertiesListKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::safe_VkPhysicalDeviceLayeredApiPropertiesListKHR()
    : … { … }

safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::safe_VkPhysicalDeviceLayeredApiPropertiesListKHR(
    const safe_VkPhysicalDeviceLayeredApiPropertiesListKHR& copy_src) { … }

safe_VkPhysicalDeviceLayeredApiPropertiesListKHR& safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::operator=(
    const safe_VkPhysicalDeviceLayeredApiPropertiesListKHR& copy_src) { … }

safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::~safe_VkPhysicalDeviceLayeredApiPropertiesListKHR() { … }

void safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::initialize(const VkPhysicalDeviceLayeredApiPropertiesListKHR* in_struct,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::initialize(const safe_VkPhysicalDeviceLayeredApiPropertiesListKHR* copy_src,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(
    const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(
    const safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::operator=(
    const safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::~safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR() { … }

void safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::initialize(const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* in_struct,
                                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::initialize(
    const safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct,
                                                                       PNextCopyState*) { … }

safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR() : … { … }

safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const safe_VkDeviceOrHostAddressConstKHR& copy_src) { … }

safe_VkDeviceOrHostAddressConstKHR& safe_VkDeviceOrHostAddressConstKHR::operator=(
    const safe_VkDeviceOrHostAddressConstKHR& copy_src) { … }

safe_VkDeviceOrHostAddressConstKHR::~safe_VkDeviceOrHostAddressConstKHR() { … }

void safe_VkDeviceOrHostAddressConstKHR::initialize(const VkDeviceOrHostAddressConstKHR* in_struct,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDeviceOrHostAddressConstKHR::initialize(const safe_VkDeviceOrHostAddressConstKHR* copy_src,
                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* in_struct, PNextCopyState*) { … }

safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR() : … { … }

safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR(const safe_VkDeviceOrHostAddressKHR& copy_src) { … }

safe_VkDeviceOrHostAddressKHR& safe_VkDeviceOrHostAddressKHR::operator=(const safe_VkDeviceOrHostAddressKHR& copy_src) { … }

safe_VkDeviceOrHostAddressKHR::~safe_VkDeviceOrHostAddressKHR() { … }

void safe_VkDeviceOrHostAddressKHR::initialize(const VkDeviceOrHostAddressKHR* in_struct,
                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkDeviceOrHostAddressKHR::initialize(const safe_VkDeviceOrHostAddressKHR* copy_src,
                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(
    const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR()
    : … { … }

safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(
    const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src) { … }

safe_VkAccelerationStructureGeometryTrianglesDataKHR& safe_VkAccelerationStructureGeometryTrianglesDataKHR::operator=(
    const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src) { … }

safe_VkAccelerationStructureGeometryTrianglesDataKHR::~safe_VkAccelerationStructureGeometryTrianglesDataKHR() { … }

void safe_VkAccelerationStructureGeometryTrianglesDataKHR::initialize(
    const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkAccelerationStructureGeometryTrianglesDataKHR::initialize(
    const safe_VkAccelerationStructureGeometryTrianglesDataKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR(
    const VkAccelerationStructureGeometryAabbsDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR()
    : … { … }

safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR(
    const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src) { … }

safe_VkAccelerationStructureGeometryAabbsDataKHR& safe_VkAccelerationStructureGeometryAabbsDataKHR::operator=(
    const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src) { … }

safe_VkAccelerationStructureGeometryAabbsDataKHR::~safe_VkAccelerationStructureGeometryAabbsDataKHR() { … }

void safe_VkAccelerationStructureGeometryAabbsDataKHR::initialize(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkAccelerationStructureGeometryAabbsDataKHR::initialize(const safe_VkAccelerationStructureGeometryAabbsDataKHR* copy_src,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR(
    const VkAccelerationStructureGeometryInstancesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR()
    : … { … }

safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR(
    const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src) { … }

safe_VkAccelerationStructureGeometryInstancesDataKHR& safe_VkAccelerationStructureGeometryInstancesDataKHR::operator=(
    const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src) { … }

safe_VkAccelerationStructureGeometryInstancesDataKHR::~safe_VkAccelerationStructureGeometryInstancesDataKHR() { … }

void safe_VkAccelerationStructureGeometryInstancesDataKHR::initialize(
    const VkAccelerationStructureGeometryInstancesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkAccelerationStructureGeometryInstancesDataKHR::initialize(
    const safe_VkAccelerationStructureGeometryInstancesDataKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR(
    const VkAccelerationStructureCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR()
    : … { … }

safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR(
    const safe_VkAccelerationStructureCreateInfoKHR& copy_src) { … }

safe_VkAccelerationStructureCreateInfoKHR& safe_VkAccelerationStructureCreateInfoKHR::operator=(
    const safe_VkAccelerationStructureCreateInfoKHR& copy_src) { … }

safe_VkAccelerationStructureCreateInfoKHR::~safe_VkAccelerationStructureCreateInfoKHR() { … }

void safe_VkAccelerationStructureCreateInfoKHR::initialize(const VkAccelerationStructureCreateInfoKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkAccelerationStructureCreateInfoKHR::initialize(const safe_VkAccelerationStructureCreateInfoKHR* copy_src,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR(
    const VkWriteDescriptorSetAccelerationStructureKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR()
    : … { … }

safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR(
    const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src) { … }

safe_VkWriteDescriptorSetAccelerationStructureKHR& safe_VkWriteDescriptorSetAccelerationStructureKHR::operator=(
    const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src) { … }

safe_VkWriteDescriptorSetAccelerationStructureKHR::~safe_VkWriteDescriptorSetAccelerationStructureKHR() { … }

void safe_VkWriteDescriptorSetAccelerationStructureKHR::initialize(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct,
                                                                   [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkWriteDescriptorSetAccelerationStructureKHR::initialize(
    const safe_VkWriteDescriptorSetAccelerationStructureKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
    const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
    const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::~safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR() { … }

void safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::initialize(
    const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
    const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
    bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
    const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::operator=(
    const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::~safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR() { … }

void safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::initialize(
    const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::initialize(
    const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR(
    const VkAccelerationStructureDeviceAddressInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR()
    : … { … }

safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR(
    const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src) { … }

safe_VkAccelerationStructureDeviceAddressInfoKHR& safe_VkAccelerationStructureDeviceAddressInfoKHR::operator=(
    const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src) { … }

safe_VkAccelerationStructureDeviceAddressInfoKHR::~safe_VkAccelerationStructureDeviceAddressInfoKHR() { … }

void safe_VkAccelerationStructureDeviceAddressInfoKHR::initialize(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkAccelerationStructureDeviceAddressInfoKHR::initialize(const safe_VkAccelerationStructureDeviceAddressInfoKHR* copy_src,
                                                                  [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR(
    const VkAccelerationStructureVersionInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR()
    : … { … }

safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR(
    const safe_VkAccelerationStructureVersionInfoKHR& copy_src) { … }

safe_VkAccelerationStructureVersionInfoKHR& safe_VkAccelerationStructureVersionInfoKHR::operator=(
    const safe_VkAccelerationStructureVersionInfoKHR& copy_src) { … }

safe_VkAccelerationStructureVersionInfoKHR::~safe_VkAccelerationStructureVersionInfoKHR() { … }

void safe_VkAccelerationStructureVersionInfoKHR::initialize(const VkAccelerationStructureVersionInfoKHR* in_struct,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkAccelerationStructureVersionInfoKHR::initialize(const safe_VkAccelerationStructureVersionInfoKHR* copy_src,
                                                            [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR(
    const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR()
    : … { … }

safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR(
    const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src) { … }

safe_VkCopyAccelerationStructureToMemoryInfoKHR& safe_VkCopyAccelerationStructureToMemoryInfoKHR::operator=(
    const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src) { … }

safe_VkCopyAccelerationStructureToMemoryInfoKHR::~safe_VkCopyAccelerationStructureToMemoryInfoKHR() { … }

void safe_VkCopyAccelerationStructureToMemoryInfoKHR::initialize(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct,
                                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkCopyAccelerationStructureToMemoryInfoKHR::initialize(const safe_VkCopyAccelerationStructureToMemoryInfoKHR* copy_src,
                                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR(
    const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR()
    : … { … }

safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR(
    const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src) { … }

safe_VkCopyMemoryToAccelerationStructureInfoKHR& safe_VkCopyMemoryToAccelerationStructureInfoKHR::operator=(
    const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src) { … }

safe_VkCopyMemoryToAccelerationStructureInfoKHR::~safe_VkCopyMemoryToAccelerationStructureInfoKHR() { … }

void safe_VkCopyMemoryToAccelerationStructureInfoKHR::initialize(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct,
                                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkCopyMemoryToAccelerationStructureInfoKHR::initialize(const safe_VkCopyMemoryToAccelerationStructureInfoKHR* copy_src,
                                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR(
    const VkCopyAccelerationStructureInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR()
    : … { … }

safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR(
    const safe_VkCopyAccelerationStructureInfoKHR& copy_src) { … }

safe_VkCopyAccelerationStructureInfoKHR& safe_VkCopyAccelerationStructureInfoKHR::operator=(
    const safe_VkCopyAccelerationStructureInfoKHR& copy_src) { … }

safe_VkCopyAccelerationStructureInfoKHR::~safe_VkCopyAccelerationStructureInfoKHR() { … }

void safe_VkCopyAccelerationStructureInfoKHR::initialize(const VkCopyAccelerationStructureInfoKHR* in_struct,
                                                         [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkCopyAccelerationStructureInfoKHR::initialize(const safe_VkCopyAccelerationStructureInfoKHR* copy_src,
                                                         [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
    const VkAccelerationStructureBuildSizesInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR()
    : … { … }

safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
    const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) { … }

safe_VkAccelerationStructureBuildSizesInfoKHR& safe_VkAccelerationStructureBuildSizesInfoKHR::operator=(
    const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) { … }

safe_VkAccelerationStructureBuildSizesInfoKHR::~safe_VkAccelerationStructureBuildSizesInfoKHR() { … }

void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src,
                                                               [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR(
    const VkRayTracingShaderGroupCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR()
    : … { … }

safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR(
    const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src) { … }

safe_VkRayTracingShaderGroupCreateInfoKHR& safe_VkRayTracingShaderGroupCreateInfoKHR::operator=(
    const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src) { … }

safe_VkRayTracingShaderGroupCreateInfoKHR::~safe_VkRayTracingShaderGroupCreateInfoKHR() { … }

void safe_VkRayTracingShaderGroupCreateInfoKHR::initialize(const VkRayTracingShaderGroupCreateInfoKHR* in_struct,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkRayTracingShaderGroupCreateInfoKHR::initialize(const safe_VkRayTracingShaderGroupCreateInfoKHR* copy_src,
                                                           [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR(
    const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR()
    : … { … }

safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR(
    const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src) { … }

safe_VkRayTracingPipelineInterfaceCreateInfoKHR& safe_VkRayTracingPipelineInterfaceCreateInfoKHR::operator=(
    const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src) { … }

safe_VkRayTracingPipelineInterfaceCreateInfoKHR::~safe_VkRayTracingPipelineInterfaceCreateInfoKHR() { … }

void safe_VkRayTracingPipelineInterfaceCreateInfoKHR::initialize(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct,
                                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkRayTracingPipelineInterfaceCreateInfoKHR::initialize(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR* copy_src,
                                                                 [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR* in_struct,
                                                                               [[maybe_unused]] PNextCopyState* copy_state,
                                                                               bool copy_pnext)
    : … { … }

safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR()
    : … { … }

safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR(
    const safe_VkRayTracingPipelineCreateInfoKHR& copy_src) { … }

safe_VkRayTracingPipelineCreateInfoKHR& safe_VkRayTracingPipelineCreateInfoKHR::operator=(
    const safe_VkRayTracingPipelineCreateInfoKHR& copy_src) { … }

safe_VkRayTracingPipelineCreateInfoKHR::~safe_VkRayTracingPipelineCreateInfoKHR() { … }

void safe_VkRayTracingPipelineCreateInfoKHR::initialize(const VkRayTracingPipelineCreateInfoKHR* in_struct,
                                                        [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkRayTracingPipelineCreateInfoKHR::initialize(const safe_VkRayTracingPipelineCreateInfoKHR* copy_src,
                                                        [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
    const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
    const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::~safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR() { … }

void safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::initialize(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct,
                                                                    [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::initialize(
    const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
    const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR()
    : … { … }

safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
    const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::operator=(
    const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src) { … }

safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::~safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR() { … }

void safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::initialize(
    const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::initialize(
    const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { … }

safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR(
    const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
    : … { … }

safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR()
    : … { … }

safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR(
    const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceRayQueryFeaturesKHR& safe_VkPhysicalDeviceRayQueryFeaturesKHR::operator=(
    const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src) { … }

safe_VkPhysicalDeviceRayQueryFeaturesKHR::~safe_VkPhysicalDeviceRayQueryFeaturesKHR() { … }

void safe_VkPhysicalDeviceRayQueryFeaturesKHR::initialize(const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

void safe_VkPhysicalDeviceRayQueryFeaturesKHR::initialize(const safe_VkPhysicalDeviceRayQueryFeaturesKHR* copy_src,
                                                          [[maybe_unused]] PNextCopyState* copy_state) { … }

}  // namespace vku

// NOLINTEND