
/* Copyright (c) 2015-2026 Valve Corporation
 * Copyright (c) 2015-2026 LunarG, Inc.
 * Copyright (c) 2015-2017, 2019, 2021 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

/*
 * This file is generated from the Khronos Vulkan XML API Registry.
 */

#pragma once

#include "api_dump.h"

//========================== Handle Implementations =========================//

template <ApiDumpFormat Format>
void dump_VkInstance(const VkInstance& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(static_cast<void*>(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkPhysicalDevice(const VkPhysicalDevice& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(static_cast<void*>(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDevice(const VkDevice& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(static_cast<void*>(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkQueue(const VkQueue& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(static_cast<void*>(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkSemaphore(const VkSemaphore& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkCommandBuffer(const VkCommandBuffer& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(static_cast<void*>(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkFence(const VkFence& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDeviceMemory(const VkDeviceMemory& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkBuffer(const VkBuffer& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkImage(const VkImage& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkQueryPool(const VkQueryPool& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkImageView(const VkImageView& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkCommandPool(const VkCommandPool& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkRenderPass(const VkRenderPass& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkFramebuffer(const VkFramebuffer& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkEvent(const VkEvent& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkBufferView(const VkBufferView& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkShaderModule(const VkShaderModule& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkPipelineCache(const VkPipelineCache& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkPipeline(const VkPipeline& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkPipelineLayout(const VkPipelineLayout& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDescriptorSetLayout(const VkDescriptorSetLayout& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkSampler(const VkSampler& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDescriptorSet(const VkDescriptorSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDescriptorPool(const VkDescriptorPool& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDescriptorUpdateTemplate(const VkDescriptorUpdateTemplate& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkSamplerYcbcrConversion(const VkSamplerYcbcrConversion& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkPrivateDataSlot(const VkPrivateDataSlot& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkSurfaceKHR(const VkSurfaceKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkSwapchainKHR(const VkSwapchainKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDisplayKHR(const VkDisplayKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDisplayModeKHR(const VkDisplayModeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkVideoSessionKHR(const VkVideoSessionKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkVideoSessionParametersKHR(const VkVideoSessionParametersKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDeferredOperationKHR(const VkDeferredOperationKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkAccelerationStructureKHR(const VkAccelerationStructureKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkPipelineBinaryKHR(const VkPipelineBinaryKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDebugReportCallbackEXT(const VkDebugReportCallbackEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkCuModuleNVX(const VkCuModuleNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkCuFunctionNVX(const VkCuFunctionNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDebugUtilsMessengerEXT(const VkDebugUtilsMessengerEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkGpaSessionAMD(const VkGpaSessionAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkTensorARM(const VkTensorARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkValidationCacheEXT(const VkValidationCacheEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkAccelerationStructureNV(const VkAccelerationStructureNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkPerformanceConfigurationINTEL(const VkPerformanceConfigurationINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkIndirectCommandsLayoutNV(const VkIndirectCommandsLayoutNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)

template <ApiDumpFormat Format>
void dump_VkCudaModuleNV(const VkCudaModuleNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkCudaFunctionNV(const VkCudaFunctionNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}
#endif  // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_USE_PLATFORM_FUCHSIA)

template <ApiDumpFormat Format>
void dump_VkBufferCollectionFUCHSIA(const VkBufferCollectionFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}
#endif  // VK_USE_PLATFORM_FUCHSIA

template <ApiDumpFormat Format>
void dump_VkMicromapEXT(const VkMicromapEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkTensorViewARM(const VkTensorViewARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkOpticalFlowSessionNV(const VkOpticalFlowSessionNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkShaderEXT(const VkShaderEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSessionARM(const VkDataGraphPipelineSessionARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkExternalComputeQueueNV(const VkExternalComputeQueueNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(static_cast<void*>(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkIndirectExecutionSetEXT(const VkIndirectExecutionSetEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkIndirectCommandsLayoutEXT(const VkIndirectCommandsLayoutEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

template <ApiDumpFormat Format>
void dump_VkShaderInstrumentationARM(const VkShaderInstrumentationARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_handle<Format>(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address);
}

//======================== Video Enum Implementations =======================//

template <ApiDumpFormat Format>
void dump_StdVideoH264ChromaFormatIdc(const StdVideoH264ChromaFormatIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME:
            dump_enum<Format>(settings, "STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_420:
            dump_enum<Format>(settings, "STD_VIDEO_H264_CHROMA_FORMAT_IDC_420", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_422:
            dump_enum<Format>(settings, "STD_VIDEO_H264_CHROMA_FORMAT_IDC_422", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_444:
            dump_enum<Format>(settings, "STD_VIDEO_H264_CHROMA_FORMAT_IDC_444", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264ProfileIdc(const StdVideoH264ProfileIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_PROFILE_IDC_BASELINE:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PROFILE_IDC_BASELINE", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_PROFILE_IDC_MAIN:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PROFILE_IDC_MAIN", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_PROFILE_IDC_HIGH:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PROFILE_IDC_HIGH", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_PROFILE_IDC_HIGH_10:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PROFILE_IDC_HIGH_10", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_PROFILE_IDC_HIGH_422:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PROFILE_IDC_HIGH_422", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_PROFILE_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PROFILE_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264LevelIdc(const StdVideoH264LevelIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_LEVEL_IDC_1_0:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_1_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_1_1:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_1_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_1_2:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_1_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_1_3:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_1_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_2_0:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_2_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_2_1:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_2_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_2_2:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_2_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_3_0:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_3_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_3_1:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_3_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_3_2:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_3_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_4_0:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_4_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_4_1:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_4_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_4_2:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_4_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_5_0:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_5_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_5_1:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_5_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_5_2:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_5_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_6_0:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_6_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_6_1:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_6_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_6_2:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_6_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_LEVEL_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_LEVEL_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264PocType(const StdVideoH264PocType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_POC_TYPE_0:
            dump_enum<Format>(settings, "STD_VIDEO_H264_POC_TYPE_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_POC_TYPE_1:
            dump_enum<Format>(settings, "STD_VIDEO_H264_POC_TYPE_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_POC_TYPE_2:
            dump_enum<Format>(settings, "STD_VIDEO_H264_POC_TYPE_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_POC_TYPE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_POC_TYPE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264AspectRatioIdc(const StdVideoH264AspectRatioIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264WeightedBipredIdc(const StdVideoH264WeightedBipredIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT:
            dump_enum<Format>(settings, "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT:
            dump_enum<Format>(settings, "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT:
            dump_enum<Format>(settings, "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264ModificationOfPicNumsIdc(const StdVideoH264ModificationOfPicNumsIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264MemMgmtControlOp(const StdVideoH264MemMgmtControlOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264CabacInitIdc(const StdVideoH264CabacInitIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_CABAC_INIT_IDC_0:
            dump_enum<Format>(settings, "STD_VIDEO_H264_CABAC_INIT_IDC_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_CABAC_INIT_IDC_1:
            dump_enum<Format>(settings, "STD_VIDEO_H264_CABAC_INIT_IDC_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_CABAC_INIT_IDC_2:
            dump_enum<Format>(settings, "STD_VIDEO_H264_CABAC_INIT_IDC_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_CABAC_INIT_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_CABAC_INIT_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264DisableDeblockingFilterIdc(const StdVideoH264DisableDeblockingFilterIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED:
            dump_enum<Format>(settings, "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED:
            dump_enum<Format>(settings, "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL:
            dump_enum<Format>(settings, "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264SliceType(const StdVideoH264SliceType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_SLICE_TYPE_P:
            dump_enum<Format>(settings, "STD_VIDEO_H264_SLICE_TYPE_P", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_SLICE_TYPE_B:
            dump_enum<Format>(settings, "STD_VIDEO_H264_SLICE_TYPE_B", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_SLICE_TYPE_I:
            dump_enum<Format>(settings, "STD_VIDEO_H264_SLICE_TYPE_I", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_SLICE_TYPE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_SLICE_TYPE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264PictureType(const StdVideoH264PictureType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_PICTURE_TYPE_P:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PICTURE_TYPE_P", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_PICTURE_TYPE_B:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PICTURE_TYPE_B", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_PICTURE_TYPE_I:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PICTURE_TYPE_I", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_PICTURE_TYPE_IDR:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PICTURE_TYPE_IDR", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_PICTURE_TYPE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_PICTURE_TYPE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264NonVclNaluType(const StdVideoH264NonVclNaluType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS:
            dump_enum<Format>(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS:
            dump_enum<Format>(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD:
            dump_enum<Format>(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX:
            dump_enum<Format>(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE:
            dump_enum<Format>(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM:
            dump_enum<Format>(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED:
            dump_enum<Format>(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeH264FieldOrderCount(const StdVideoDecodeH264FieldOrderCount object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP:
            dump_enum<Format>(settings, "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM:
            dump_enum<Format>(settings, "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265ChromaFormatIdc(const StdVideoH265ChromaFormatIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME:
            dump_enum<Format>(settings, "STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_420:
            dump_enum<Format>(settings, "STD_VIDEO_H265_CHROMA_FORMAT_IDC_420", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_422:
            dump_enum<Format>(settings, "STD_VIDEO_H265_CHROMA_FORMAT_IDC_422", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_444:
            dump_enum<Format>(settings, "STD_VIDEO_H265_CHROMA_FORMAT_IDC_444", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265ProfileIdc(const StdVideoH265ProfileIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H265_PROFILE_IDC_MAIN:
            dump_enum<Format>(settings, "STD_VIDEO_H265_PROFILE_IDC_MAIN", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_PROFILE_IDC_MAIN_10:
            dump_enum<Format>(settings, "STD_VIDEO_H265_PROFILE_IDC_MAIN_10", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE:
            dump_enum<Format>(settings, "STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS:
            dump_enum<Format>(settings, "STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS:
            dump_enum<Format>(settings, "STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_PROFILE_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H265_PROFILE_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265LevelIdc(const StdVideoH265LevelIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H265_LEVEL_IDC_1_0:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_1_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_2_0:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_2_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_2_1:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_2_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_3_0:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_3_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_3_1:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_3_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_4_0:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_4_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_4_1:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_4_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_5_0:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_5_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_5_1:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_5_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_5_2:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_5_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_6_0:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_6_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_6_1:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_6_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_6_2:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_6_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_LEVEL_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H265_LEVEL_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265SliceType(const StdVideoH265SliceType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H265_SLICE_TYPE_B:
            dump_enum<Format>(settings, "STD_VIDEO_H265_SLICE_TYPE_B", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_SLICE_TYPE_P:
            dump_enum<Format>(settings, "STD_VIDEO_H265_SLICE_TYPE_P", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_SLICE_TYPE_I:
            dump_enum<Format>(settings, "STD_VIDEO_H265_SLICE_TYPE_I", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_SLICE_TYPE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H265_SLICE_TYPE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265PictureType(const StdVideoH265PictureType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H265_PICTURE_TYPE_P:
            dump_enum<Format>(settings, "STD_VIDEO_H265_PICTURE_TYPE_P", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_PICTURE_TYPE_B:
            dump_enum<Format>(settings, "STD_VIDEO_H265_PICTURE_TYPE_B", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_PICTURE_TYPE_I:
            dump_enum<Format>(settings, "STD_VIDEO_H265_PICTURE_TYPE_I", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_PICTURE_TYPE_IDR:
            dump_enum<Format>(settings, "STD_VIDEO_H265_PICTURE_TYPE_IDR", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_PICTURE_TYPE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H265_PICTURE_TYPE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265AspectRatioIdc(const StdVideoH265AspectRatioIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1Profile(const StdVideoAV1Profile object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_AV1_PROFILE_MAIN:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_PROFILE_MAIN", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_PROFILE_HIGH:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_PROFILE_HIGH", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_PROFILE_PROFESSIONAL:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_PROFILE_PROFESSIONAL", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_PROFILE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_PROFILE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1Level(const StdVideoAV1Level object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_AV1_LEVEL_2_0:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_2_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_2_1:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_2_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_2_2:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_2_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_2_3:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_2_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_3_0:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_3_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_3_1:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_3_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_3_2:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_3_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_3_3:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_3_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_4_0:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_4_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_4_1:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_4_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_4_2:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_4_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_4_3:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_4_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_5_0:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_5_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_5_1:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_5_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_5_2:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_5_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_5_3:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_5_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_6_0:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_6_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_6_1:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_6_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_6_2:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_6_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_6_3:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_6_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_7_0:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_7_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_7_1:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_7_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_7_2:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_7_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_7_3:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_7_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_LEVEL_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_LEVEL_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1FrameType(const StdVideoAV1FrameType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_AV1_FRAME_TYPE_KEY:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_FRAME_TYPE_KEY", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_FRAME_TYPE_INTER:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_FRAME_TYPE_INTER", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_FRAME_TYPE_SWITCH:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_FRAME_TYPE_SWITCH", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_FRAME_TYPE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_FRAME_TYPE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1ReferenceName(const StdVideoAV1ReferenceName object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_REFERENCE_NAME_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_REFERENCE_NAME_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1InterpolationFilter(const StdVideoAV1InterpolationFilter object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1TxMode(const StdVideoAV1TxMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_AV1_TX_MODE_ONLY_4X4:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TX_MODE_ONLY_4X4", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TX_MODE_LARGEST:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TX_MODE_LARGEST", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TX_MODE_SELECT:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TX_MODE_SELECT", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TX_MODE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TX_MODE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1FrameRestorationType(const StdVideoAV1FrameRestorationType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1ColorPrimaries(const StdVideoAV1ColorPrimaries object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1TransferCharacteristics(const StdVideoAV1TransferCharacteristics object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1MatrixCoefficients(const StdVideoAV1MatrixCoefficients object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1ChromaSamplePosition(const StdVideoAV1ChromaSamplePosition object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9Profile(const StdVideoVP9Profile object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_VP9_PROFILE_0:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_PROFILE_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_PROFILE_1:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_PROFILE_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_PROFILE_2:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_PROFILE_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_PROFILE_3:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_PROFILE_3", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_PROFILE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_PROFILE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9Level(const StdVideoVP9Level object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_VP9_LEVEL_1_0:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_1_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_1_1:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_1_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_2_0:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_2_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_2_1:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_2_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_3_0:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_3_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_3_1:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_3_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_4_0:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_4_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_4_1:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_4_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_5_0:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_5_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_5_1:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_5_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_5_2:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_5_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_6_0:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_6_0", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_6_1:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_6_1", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_6_2:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_6_2", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_LEVEL_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_LEVEL_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9FrameType(const StdVideoVP9FrameType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_VP9_FRAME_TYPE_KEY:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_FRAME_TYPE_KEY", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_FRAME_TYPE_NON_KEY:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_FRAME_TYPE_NON_KEY", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_FRAME_TYPE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_FRAME_TYPE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9ReferenceName(const StdVideoVP9ReferenceName object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_REFERENCE_NAME_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_REFERENCE_NAME_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9InterpolationFilter(const StdVideoVP9InterpolationFilter object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9ColorSpace(const StdVideoVP9ColorSpace object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_COLOR_SPACE_BT_601:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_COLOR_SPACE_BT_601", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_COLOR_SPACE_BT_709:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_COLOR_SPACE_BT_709", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_COLOR_SPACE_BT_2020:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_COLOR_SPACE_BT_2020", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_COLOR_SPACE_RESERVED:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_COLOR_SPACE_RESERVED", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_COLOR_SPACE_RGB:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_COLOR_SPACE_RGB", static_cast<uint32_t>(object));
            break;
        case STD_VIDEO_VP9_COLOR_SPACE_INVALID:
            dump_enum<Format>(settings, "STD_VIDEO_VP9_COLOR_SPACE_INVALID", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

//=========================== Enum Implementations ==========================//

template <ApiDumpFormat Format>
void dump_return_value_VkResult(const VkResult& object, const ApiDumpSettings& settings) {
    switch ((int64_t)object) {
        case VK_SUCCESS:
            dump_enum<Format>(settings, "VK_SUCCESS", static_cast<int32_t>(object));
            break;
        case VK_NOT_READY:
            dump_enum<Format>(settings, "VK_NOT_READY", static_cast<int32_t>(object));
            break;
        case VK_TIMEOUT:
            dump_enum<Format>(settings, "VK_TIMEOUT", static_cast<int32_t>(object));
            break;
        case VK_EVENT_SET:
            dump_enum<Format>(settings, "VK_EVENT_SET", static_cast<int32_t>(object));
            break;
        case VK_EVENT_RESET:
            dump_enum<Format>(settings, "VK_EVENT_RESET", static_cast<int32_t>(object));
            break;
        case VK_INCOMPLETE:
            dump_enum<Format>(settings, "VK_INCOMPLETE", static_cast<int32_t>(object));
            break;
        case VK_ERROR_OUT_OF_HOST_MEMORY:
            dump_enum<Format>(settings, "VK_ERROR_OUT_OF_HOST_MEMORY", static_cast<int32_t>(object));
            break;
        case VK_ERROR_OUT_OF_DEVICE_MEMORY:
            dump_enum<Format>(settings, "VK_ERROR_OUT_OF_DEVICE_MEMORY", static_cast<int32_t>(object));
            break;
        case VK_ERROR_INITIALIZATION_FAILED:
            dump_enum<Format>(settings, "VK_ERROR_INITIALIZATION_FAILED", static_cast<int32_t>(object));
            break;
        case VK_ERROR_DEVICE_LOST:
            dump_enum<Format>(settings, "VK_ERROR_DEVICE_LOST", static_cast<int32_t>(object));
            break;
        case VK_ERROR_MEMORY_MAP_FAILED:
            dump_enum<Format>(settings, "VK_ERROR_MEMORY_MAP_FAILED", static_cast<int32_t>(object));
            break;
        case VK_ERROR_LAYER_NOT_PRESENT:
            dump_enum<Format>(settings, "VK_ERROR_LAYER_NOT_PRESENT", static_cast<int32_t>(object));
            break;
        case VK_ERROR_EXTENSION_NOT_PRESENT:
            dump_enum<Format>(settings, "VK_ERROR_EXTENSION_NOT_PRESENT", static_cast<int32_t>(object));
            break;
        case VK_ERROR_FEATURE_NOT_PRESENT:
            dump_enum<Format>(settings, "VK_ERROR_FEATURE_NOT_PRESENT", static_cast<int32_t>(object));
            break;
        case VK_ERROR_INCOMPATIBLE_DRIVER:
            dump_enum<Format>(settings, "VK_ERROR_INCOMPATIBLE_DRIVER", static_cast<int32_t>(object));
            break;
        case VK_ERROR_TOO_MANY_OBJECTS:
            dump_enum<Format>(settings, "VK_ERROR_TOO_MANY_OBJECTS", static_cast<int32_t>(object));
            break;
        case VK_ERROR_FORMAT_NOT_SUPPORTED:
            dump_enum<Format>(settings, "VK_ERROR_FORMAT_NOT_SUPPORTED", static_cast<int32_t>(object));
            break;
        case VK_ERROR_FRAGMENTED_POOL:
            dump_enum<Format>(settings, "VK_ERROR_FRAGMENTED_POOL", static_cast<int32_t>(object));
            break;
        case VK_ERROR_UNKNOWN:
            dump_enum<Format>(settings, "VK_ERROR_UNKNOWN", static_cast<int32_t>(object));
            break;
        case VK_ERROR_VALIDATION_FAILED:
            dump_enum<Format>(settings, "VK_ERROR_VALIDATION_FAILED", static_cast<int32_t>(object));
            break;
        case VK_ERROR_OUT_OF_POOL_MEMORY:
            dump_enum<Format>(settings, "VK_ERROR_OUT_OF_POOL_MEMORY", static_cast<int32_t>(object));
            break;
        case VK_ERROR_INVALID_EXTERNAL_HANDLE:
            dump_enum<Format>(settings, "VK_ERROR_INVALID_EXTERNAL_HANDLE", static_cast<int32_t>(object));
            break;
        case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS:
            dump_enum<Format>(settings, "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS", static_cast<int32_t>(object));
            break;
        case VK_ERROR_FRAGMENTATION:
            dump_enum<Format>(settings, "VK_ERROR_FRAGMENTATION", static_cast<int32_t>(object));
            break;
        case VK_PIPELINE_COMPILE_REQUIRED:
            dump_enum<Format>(settings, "VK_PIPELINE_COMPILE_REQUIRED", static_cast<int32_t>(object));
            break;
        case VK_ERROR_NOT_PERMITTED:
            dump_enum<Format>(settings, "VK_ERROR_NOT_PERMITTED", static_cast<int32_t>(object));
            break;
        case VK_ERROR_SURFACE_LOST_KHR:
            dump_enum<Format>(settings, "VK_ERROR_SURFACE_LOST_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
            dump_enum<Format>(settings, "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR", static_cast<int32_t>(object));
            break;
        case VK_SUBOPTIMAL_KHR:
            dump_enum<Format>(settings, "VK_SUBOPTIMAL_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_OUT_OF_DATE_KHR:
            dump_enum<Format>(settings, "VK_ERROR_OUT_OF_DATE_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
            dump_enum<Format>(settings, "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_INVALID_SHADER_NV:
            dump_enum<Format>(settings, "VK_ERROR_INVALID_SHADER_NV", static_cast<int32_t>(object));
            break;
        case VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR:
            dump_enum<Format>(settings, "VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR:
            dump_enum<Format>(settings, "VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR:
            dump_enum<Format>(settings, "VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR:
            dump_enum<Format>(settings, "VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR:
            dump_enum<Format>(settings, "VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR:
            dump_enum<Format>(settings, "VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT:
            dump_enum<Format>(settings, "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT", static_cast<int32_t>(object));
            break;
        case VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT:
            dump_enum<Format>(settings, "VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT", static_cast<int32_t>(object));
            break;
        case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT:
            dump_enum<Format>(settings, "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT", static_cast<int32_t>(object));
            break;
        case VK_THREAD_IDLE_KHR:
            dump_enum<Format>(settings, "VK_THREAD_IDLE_KHR", static_cast<int32_t>(object));
            break;
        case VK_THREAD_DONE_KHR:
            dump_enum<Format>(settings, "VK_THREAD_DONE_KHR", static_cast<int32_t>(object));
            break;
        case VK_OPERATION_DEFERRED_KHR:
            dump_enum<Format>(settings, "VK_OPERATION_DEFERRED_KHR", static_cast<int32_t>(object));
            break;
        case VK_OPERATION_NOT_DEFERRED_KHR:
            dump_enum<Format>(settings, "VK_OPERATION_NOT_DEFERRED_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR:
            dump_enum<Format>(settings, "VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_COMPRESSION_EXHAUSTED_EXT:
            dump_enum<Format>(settings, "VK_ERROR_COMPRESSION_EXHAUSTED_EXT", static_cast<int32_t>(object));
            break;
        case VK_INCOMPATIBLE_SHADER_BINARY_EXT:
            dump_enum<Format>(settings, "VK_INCOMPATIBLE_SHADER_BINARY_EXT", static_cast<int32_t>(object));
            break;
        case VK_PIPELINE_BINARY_MISSING_KHR:
            dump_enum<Format>(settings, "VK_PIPELINE_BINARY_MISSING_KHR", static_cast<int32_t>(object));
            break;
        case VK_ERROR_NOT_ENOUGH_SPACE_KHR:
            dump_enum<Format>(settings, "VK_ERROR_NOT_ENOUGH_SPACE_KHR", static_cast<int32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<int32_t>(object));
    }
}
template <ApiDumpFormat Format>
void dump_VkResult(const VkResult object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_return_value_VkResult<Format>(object, settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkStructureType(const VkStructureType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_STRUCTURE_TYPE_APPLICATION_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_APPLICATION_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBMIT_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBMIT_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_BARRIER", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_END_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBPASS_END_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEPENDENCY_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEPENDENCY_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBMIT_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBMIT_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COPY_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_COPY_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_COPY_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_COPY_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_BLIT_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_BLIT_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDERING_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_MAP_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDERING_AREA_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_HDR_METADATA_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_HDR_METADATA_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD", static_cast<uint32_t>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX", static_cast<uint32_t>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GEOMETRY_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GEOMETRY_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PRESENT_ID_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT", static_cast<uint32_t>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV", static_cast<uint32_t>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPATCH_PARAMETERS_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPATCH_PARAMETERS_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_COPY_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD", static_cast<uint32_t>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX", static_cast<uint32_t>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_TOSA_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_TOSA_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_EXPLICIT_TILING_FORMAT_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_EXPLICIT_TILING_FORMAT_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_TENSOR_ROLLING_BACKING_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_TENSOR_ROLLING_BACKING_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OCP_MICROSCALING_TYPES_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OCP_MICROSCALING_TYPES_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV:
            dump_enum<Format>(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkObjectType(const VkObjectType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_OBJECT_TYPE_UNKNOWN:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_UNKNOWN", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_INSTANCE:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_INSTANCE", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_PHYSICAL_DEVICE", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DEVICE:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DEVICE", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_QUEUE:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_QUEUE", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_SEMAPHORE:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_SEMAPHORE", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_COMMAND_BUFFER:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_COMMAND_BUFFER", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_FENCE:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_FENCE", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DEVICE_MEMORY:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DEVICE_MEMORY", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_BUFFER:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_BUFFER", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_IMAGE:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_IMAGE", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_EVENT:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_EVENT", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_QUERY_POOL:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_QUERY_POOL", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_BUFFER_VIEW:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_BUFFER_VIEW", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_IMAGE_VIEW:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_IMAGE_VIEW", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_SHADER_MODULE:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_SHADER_MODULE", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_PIPELINE_CACHE:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_PIPELINE_CACHE", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_PIPELINE_LAYOUT:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_PIPELINE_LAYOUT", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_RENDER_PASS:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_RENDER_PASS", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_PIPELINE:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_PIPELINE", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_SAMPLER:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_SAMPLER", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DESCRIPTOR_POOL", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DESCRIPTOR_SET:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DESCRIPTOR_SET", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_FRAMEBUFFER:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_FRAMEBUFFER", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_COMMAND_POOL:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_COMMAND_POOL", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_PRIVATE_DATA_SLOT:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_SURFACE_KHR:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_SURFACE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_SWAPCHAIN_KHR:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_SWAPCHAIN_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DISPLAY_KHR:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DISPLAY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DISPLAY_MODE_KHR:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DISPLAY_MODE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_VIDEO_SESSION_KHR:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_VIDEO_SESSION_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_CU_MODULE_NVX:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_CU_MODULE_NVX", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_CU_FUNCTION_NVX:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_CU_FUNCTION_NVX", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_GPA_SESSION_AMD:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_GPA_SESSION_AMD", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_VALIDATION_CACHE_EXT:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV", static_cast<uint32_t>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case VK_OBJECT_TYPE_CUDA_MODULE_NV:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_CUDA_MODULE_NV", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_CUDA_FUNCTION_NV:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_CUDA_FUNCTION_NV", static_cast<uint32_t>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS
        case VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_MICROMAP_EXT:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_MICROMAP_EXT", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_TENSOR_ARM:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_TENSOR_ARM", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_TENSOR_VIEW_ARM:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_TENSOR_VIEW_ARM", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_SHADER_EXT:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_SHADER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_PIPELINE_BINARY_KHR:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_PIPELINE_BINARY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT", static_cast<uint32_t>(object));
            break;
        case VK_OBJECT_TYPE_SHADER_INSTRUMENTATION_ARM:
            dump_enum<Format>(settings, "VK_OBJECT_TYPE_SHADER_INSTRUMENTATION_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkVendorId(const VkVendorId object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_VENDOR_ID_KHRONOS:
            dump_enum<Format>(settings, "VK_VENDOR_ID_KHRONOS", static_cast<uint32_t>(object));
            break;
        case VK_VENDOR_ID_VIV:
            dump_enum<Format>(settings, "VK_VENDOR_ID_VIV", static_cast<uint32_t>(object));
            break;
        case VK_VENDOR_ID_VSI:
            dump_enum<Format>(settings, "VK_VENDOR_ID_VSI", static_cast<uint32_t>(object));
            break;
        case VK_VENDOR_ID_KAZAN:
            dump_enum<Format>(settings, "VK_VENDOR_ID_KAZAN", static_cast<uint32_t>(object));
            break;
        case VK_VENDOR_ID_CODEPLAY:
            dump_enum<Format>(settings, "VK_VENDOR_ID_CODEPLAY", static_cast<uint32_t>(object));
            break;
        case VK_VENDOR_ID_MESA:
            dump_enum<Format>(settings, "VK_VENDOR_ID_MESA", static_cast<uint32_t>(object));
            break;
        case VK_VENDOR_ID_POCL:
            dump_enum<Format>(settings, "VK_VENDOR_ID_POCL", static_cast<uint32_t>(object));
            break;
        case VK_VENDOR_ID_MOBILEYE:
            dump_enum<Format>(settings, "VK_VENDOR_ID_MOBILEYE", static_cast<uint32_t>(object));
            break;
        case VK_VENDOR_ID_APE:
            dump_enum<Format>(settings, "VK_VENDOR_ID_APE", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkSystemAllocationScope(const VkSystemAllocationScope object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SYSTEM_ALLOCATION_SCOPE_COMMAND:
            dump_enum<Format>(settings, "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND", static_cast<uint32_t>(object));
            break;
        case VK_SYSTEM_ALLOCATION_SCOPE_OBJECT:
            dump_enum<Format>(settings, "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT", static_cast<uint32_t>(object));
            break;
        case VK_SYSTEM_ALLOCATION_SCOPE_CACHE:
            dump_enum<Format>(settings, "VK_SYSTEM_ALLOCATION_SCOPE_CACHE", static_cast<uint32_t>(object));
            break;
        case VK_SYSTEM_ALLOCATION_SCOPE_DEVICE:
            dump_enum<Format>(settings, "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE", static_cast<uint32_t>(object));
            break;
        case VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE:
            dump_enum<Format>(settings, "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkInternalAllocationType(const VkInternalAllocationType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE:
            dump_enum<Format>(settings, "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkFormat(const VkFormat object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_FORMAT_UNDEFINED:
            dump_enum<Format>(settings, "VK_FORMAT_UNDEFINED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R4G4_UNORM_PACK8:
            dump_enum<Format>(settings, "VK_FORMAT_R4G4_UNORM_PACK8", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_R4G4B4A4_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_B4G4R4A4_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R5G6B5_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_R5G6B5_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B5G6R5_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_B5G6R5_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_R5G5B5A1_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_B5G5R5A1_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_A1R5G5B5_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R8_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8_SNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R8_SNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8_USCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R8_USCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8_SSCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R8_SSCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R8_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R8_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8_SRGB:
            dump_enum<Format>(settings, "VK_FORMAT_R8_SRGB", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8_SNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8_SNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8_USCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8_USCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8_SSCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8_SSCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8_SRGB:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8_SRGB", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8_SNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8_SNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8_USCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8_USCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8_SSCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8_SSCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8_SRGB:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8_SRGB", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8_SNORM:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8_SNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8_USCALED:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8_USCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8_SSCALED:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8_SSCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8_SRGB:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8_SRGB", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8A8_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8A8_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8A8_SNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8A8_SNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8A8_USCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8A8_USCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8A8_SSCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8A8_SSCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8A8_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8A8_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8A8_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8A8_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8G8B8A8_SRGB:
            dump_enum<Format>(settings, "VK_FORMAT_R8G8B8A8_SRGB", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8A8_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8A8_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8A8_SNORM:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8A8_SNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8A8_USCALED:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8A8_USCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8A8_SSCALED:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8A8_SSCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8A8_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8A8_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8A8_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8A8_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8A8_SRGB:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8A8_SRGB", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A8B8G8R8_UNORM_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A8B8G8R8_SNORM_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A8B8G8R8_USCALED_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A8B8G8R8_SSCALED_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A8B8G8R8_UINT_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A8B8G8R8_UINT_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A8B8G8R8_SINT_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A8B8G8R8_SINT_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A8B8G8R8_SRGB_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2R10G10B10_UNORM_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2R10G10B10_SNORM_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2R10G10B10_USCALED_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2R10G10B10_SSCALED_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2R10G10B10_UINT_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2R10G10B10_UINT_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2R10G10B10_SINT_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2R10G10B10_SINT_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2B10G10R10_UNORM_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2B10G10R10_SNORM_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2B10G10R10_USCALED_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2B10G10R10_SSCALED_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2B10G10R10_UINT_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2B10G10R10_UINT_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A2B10G10R10_SINT_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_A2B10G10R10_SINT_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R16_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16_SNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R16_SNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16_USCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R16_USCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16_SSCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R16_SSCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R16_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R16_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R16_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16_SNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16_SNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16_USCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16_USCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16_SSCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16_SSCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16_SNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16_SNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16_USCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16_USCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16_SSCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16_SSCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16A16_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16A16_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16A16_SNORM:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16A16_SNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16A16_USCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16A16_USCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16A16_SSCALED:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16A16_SSCALED", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16A16_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16A16_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16A16_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16A16_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16B16A16_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16B16A16_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R32_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R32_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R32_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32G32_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R32G32_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32G32_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R32G32_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32G32_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R32G32_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32G32B32_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R32G32B32_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32G32B32_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R32G32B32_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32G32B32_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R32G32B32_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32G32B32A32_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R32G32B32A32_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32G32B32A32_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R32G32B32A32_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R32G32B32A32_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R32G32B32A32_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R64_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R64_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R64_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64G64_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R64G64_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64G64_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R64G64_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64G64_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R64G64_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64G64B64_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R64G64B64_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64G64B64_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R64G64B64_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64G64B64_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R64G64B64_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64G64B64A64_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_R64G64B64A64_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64G64B64A64_SINT:
            dump_enum<Format>(settings, "VK_FORMAT_R64G64B64A64_SINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R64G64B64A64_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_R64G64B64A64_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_B10G11R11_UFLOAT_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_D16_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_D16_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_X8_D24_UNORM_PACK32:
            dump_enum<Format>(settings, "VK_FORMAT_X8_D24_UNORM_PACK32", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_D32_SFLOAT:
            dump_enum<Format>(settings, "VK_FORMAT_D32_SFLOAT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_S8_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_S8_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_D16_UNORM_S8_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_D16_UNORM_S8_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_D24_UNORM_S8_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_D24_UNORM_S8_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_D32_SFLOAT_S8_UINT:
            dump_enum<Format>(settings, "VK_FORMAT_D32_SFLOAT_S8_UINT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC1_RGB_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC1_RGB_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC1_RGBA_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC1_RGBA_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC2_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC2_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC2_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC2_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC3_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC3_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC3_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC3_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC4_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC4_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC4_SNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC4_SNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC5_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC5_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC5_SNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC5_SNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC6H_UFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC6H_UFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC6H_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC6H_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC7_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC7_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_BC7_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_BC7_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_EAC_R11_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_EAC_R11_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_EAC_R11_SNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_EAC_R11_SNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_EAC_R11G11_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_EAC_R11G11_SNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x4_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x4_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x4_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x4_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x5_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x5_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x5_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x5_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x6_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x6_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_8x5_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_8x5_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_8x6_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_8x6_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_8x8_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_8x8_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x5_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x5_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x6_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x6_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x8_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x8_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x10_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x10_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_12x10_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_12x10_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_12x12_UNORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_12x12_SRGB_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G8B8G8R8_422_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G8B8G8R8_422_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B8G8R8G8_422_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_B8G8R8G8_422_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R10X6_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_R10X6_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_R10X6G10X6_UNORM_2PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R12X4_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_R12X4_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_R12X4G12X4_UNORM_2PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G16B16G16R16_422_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G16B16G16R16_422_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_B16G16R16G16_422_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_B16G16R16G16_422_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G8_B8R8_2PLANE_444_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_G16_B16R16_2PLANE_444_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_A4R4G4B4_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_A4B4G4R4_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A1B5G5R5_UNORM_PACK16:
            dump_enum<Format>(settings, "VK_FORMAT_A1B5G5R5_UNORM_PACK16", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_A8_UNORM:
            dump_enum<Format>(settings, "VK_FORMAT_A8_UNORM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG:
            dump_enum<Format>(settings, "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG:
            dump_enum<Format>(settings, "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG:
            dump_enum<Format>(settings, "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG:
            dump_enum<Format>(settings, "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG:
            dump_enum<Format>(settings, "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG:
            dump_enum<Format>(settings, "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG:
            dump_enum<Format>(settings, "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:
            dump_enum<Format>(settings, "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT:
            dump_enum<Format>(settings, "VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8_BOOL_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R8_BOOL_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16_SFLOAT_FPENCODING_BFLOAT16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R16_SFLOAT_FPENCODING_BFLOAT16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E4M3_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E4M3_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E5M2_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E5M2_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R16G16_SFIXED5_NV:
            dump_enum<Format>(settings, "VK_FORMAT_R16G16_SFIXED5_NV", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R10X6_UINT_PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R10X6_UINT_PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R12X4_UINT_PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R12X4_UINT_PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R14X2_UINT_PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R14X2_UINT_PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R14X2_UNORM_PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R14X2_UNORM_PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM", static_cast<uint32_t>(object));
            break;
        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM:
            dump_enum<Format>(settings, "VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageTiling(const VkImageTiling object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_IMAGE_TILING_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_TILING_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_TILING_LINEAR:
            dump_enum<Format>(settings, "VK_IMAGE_TILING_LINEAR", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT:
            dump_enum<Format>(settings, "VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageType(const VkImageType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_IMAGE_TYPE_1D:
            dump_enum<Format>(settings, "VK_IMAGE_TYPE_1D", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_TYPE_2D:
            dump_enum<Format>(settings, "VK_IMAGE_TYPE_2D", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_TYPE_3D:
            dump_enum<Format>(settings, "VK_IMAGE_TYPE_3D", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceType(const VkPhysicalDeviceType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PHYSICAL_DEVICE_TYPE_OTHER:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_TYPE_OTHER", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_TYPE_CPU:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_TYPE_CPU", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueryType(const VkQueryType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_QUERY_TYPE_OCCLUSION:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_OCCLUSION", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_PIPELINE_STATISTICS:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_PIPELINE_STATISTICS", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_TIMESTAMP:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_TIMESTAMP", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_TIME_ELAPSED_QCOM:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_TIME_ELAPSED_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT:
            dump_enum<Format>(settings, "VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkSharingMode(const VkSharingMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SHARING_MODE_EXCLUSIVE:
            dump_enum<Format>(settings, "VK_SHARING_MODE_EXCLUSIVE", static_cast<uint32_t>(object));
            break;
        case VK_SHARING_MODE_CONCURRENT:
            dump_enum<Format>(settings, "VK_SHARING_MODE_CONCURRENT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageLayout(const VkImageLayout object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_IMAGE_LAYOUT_UNDEFINED:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_UNDEFINED", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_GENERAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_GENERAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_PREINITIALIZED:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_PREINITIALIZED", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT:
            dump_enum<Format>(settings, "VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkComponentSwizzle(const VkComponentSwizzle object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COMPONENT_SWIZZLE_IDENTITY:
            dump_enum<Format>(settings, "VK_COMPONENT_SWIZZLE_IDENTITY", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_SWIZZLE_ZERO:
            dump_enum<Format>(settings, "VK_COMPONENT_SWIZZLE_ZERO", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_SWIZZLE_ONE:
            dump_enum<Format>(settings, "VK_COMPONENT_SWIZZLE_ONE", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_SWIZZLE_R:
            dump_enum<Format>(settings, "VK_COMPONENT_SWIZZLE_R", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_SWIZZLE_G:
            dump_enum<Format>(settings, "VK_COMPONENT_SWIZZLE_G", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_SWIZZLE_B:
            dump_enum<Format>(settings, "VK_COMPONENT_SWIZZLE_B", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_SWIZZLE_A:
            dump_enum<Format>(settings, "VK_COMPONENT_SWIZZLE_A", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageViewType(const VkImageViewType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_IMAGE_VIEW_TYPE_1D:
            dump_enum<Format>(settings, "VK_IMAGE_VIEW_TYPE_1D", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_VIEW_TYPE_2D:
            dump_enum<Format>(settings, "VK_IMAGE_VIEW_TYPE_2D", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_VIEW_TYPE_3D:
            dump_enum<Format>(settings, "VK_IMAGE_VIEW_TYPE_3D", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_VIEW_TYPE_CUBE:
            dump_enum<Format>(settings, "VK_IMAGE_VIEW_TYPE_CUBE", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_VIEW_TYPE_1D_ARRAY:
            dump_enum<Format>(settings, "VK_IMAGE_VIEW_TYPE_1D_ARRAY", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_VIEW_TYPE_2D_ARRAY:
            dump_enum<Format>(settings, "VK_IMAGE_VIEW_TYPE_2D_ARRAY", static_cast<uint32_t>(object));
            break;
        case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
            dump_enum<Format>(settings, "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferLevel(const VkCommandBufferLevel object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COMMAND_BUFFER_LEVEL_PRIMARY:
            dump_enum<Format>(settings, "VK_COMMAND_BUFFER_LEVEL_PRIMARY", static_cast<uint32_t>(object));
            break;
        case VK_COMMAND_BUFFER_LEVEL_SECONDARY:
            dump_enum<Format>(settings, "VK_COMMAND_BUFFER_LEVEL_SECONDARY", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndexType(const VkIndexType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_INDEX_TYPE_UINT16:
            dump_enum<Format>(settings, "VK_INDEX_TYPE_UINT16", static_cast<uint32_t>(object));
            break;
        case VK_INDEX_TYPE_UINT32:
            dump_enum<Format>(settings, "VK_INDEX_TYPE_UINT32", static_cast<uint32_t>(object));
            break;
        case VK_INDEX_TYPE_UINT8:
            dump_enum<Format>(settings, "VK_INDEX_TYPE_UINT8", static_cast<uint32_t>(object));
            break;
        case VK_INDEX_TYPE_NONE_KHR:
            dump_enum<Format>(settings, "VK_INDEX_TYPE_NONE_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PIPELINE_CACHE_HEADER_VERSION_ONE:
            dump_enum<Format>(settings, "VK_PIPELINE_CACHE_HEADER_VERSION_ONE", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM:
            dump_enum<Format>(settings, "VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkBorderColor(const VkBorderColor object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
            dump_enum<Format>(settings, "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK", static_cast<uint32_t>(object));
            break;
        case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
            dump_enum<Format>(settings, "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK", static_cast<uint32_t>(object));
            break;
        case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
            dump_enum<Format>(settings, "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK", static_cast<uint32_t>(object));
            break;
        case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
            dump_enum<Format>(settings, "VK_BORDER_COLOR_INT_OPAQUE_BLACK", static_cast<uint32_t>(object));
            break;
        case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
            dump_enum<Format>(settings, "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE", static_cast<uint32_t>(object));
            break;
        case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
            dump_enum<Format>(settings, "VK_BORDER_COLOR_INT_OPAQUE_WHITE", static_cast<uint32_t>(object));
            break;
        case VK_BORDER_COLOR_FLOAT_CUSTOM_EXT:
            dump_enum<Format>(settings, "VK_BORDER_COLOR_FLOAT_CUSTOM_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BORDER_COLOR_INT_CUSTOM_EXT:
            dump_enum<Format>(settings, "VK_BORDER_COLOR_INT_CUSTOM_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkFilter(const VkFilter object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_FILTER_NEAREST:
            dump_enum<Format>(settings, "VK_FILTER_NEAREST", static_cast<uint32_t>(object));
            break;
        case VK_FILTER_LINEAR:
            dump_enum<Format>(settings, "VK_FILTER_LINEAR", static_cast<uint32_t>(object));
            break;
        case VK_FILTER_CUBIC_EXT:
            dump_enum<Format>(settings, "VK_FILTER_CUBIC_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerAddressMode(const VkSamplerAddressMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SAMPLER_ADDRESS_MODE_REPEAT:
            dump_enum<Format>(settings, "VK_SAMPLER_ADDRESS_MODE_REPEAT", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT:
            dump_enum<Format>(settings, "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
            dump_enum<Format>(settings, "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
            dump_enum<Format>(settings, "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE:
            dump_enum<Format>(settings, "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkCompareOp(const VkCompareOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COMPARE_OP_NEVER:
            dump_enum<Format>(settings, "VK_COMPARE_OP_NEVER", static_cast<uint32_t>(object));
            break;
        case VK_COMPARE_OP_LESS:
            dump_enum<Format>(settings, "VK_COMPARE_OP_LESS", static_cast<uint32_t>(object));
            break;
        case VK_COMPARE_OP_EQUAL:
            dump_enum<Format>(settings, "VK_COMPARE_OP_EQUAL", static_cast<uint32_t>(object));
            break;
        case VK_COMPARE_OP_LESS_OR_EQUAL:
            dump_enum<Format>(settings, "VK_COMPARE_OP_LESS_OR_EQUAL", static_cast<uint32_t>(object));
            break;
        case VK_COMPARE_OP_GREATER:
            dump_enum<Format>(settings, "VK_COMPARE_OP_GREATER", static_cast<uint32_t>(object));
            break;
        case VK_COMPARE_OP_NOT_EQUAL:
            dump_enum<Format>(settings, "VK_COMPARE_OP_NOT_EQUAL", static_cast<uint32_t>(object));
            break;
        case VK_COMPARE_OP_GREATER_OR_EQUAL:
            dump_enum<Format>(settings, "VK_COMPARE_OP_GREATER_OR_EQUAL", static_cast<uint32_t>(object));
            break;
        case VK_COMPARE_OP_ALWAYS:
            dump_enum<Format>(settings, "VK_COMPARE_OP_ALWAYS", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerMipmapMode(const VkSamplerMipmapMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SAMPLER_MIPMAP_MODE_NEAREST:
            dump_enum<Format>(settings, "VK_SAMPLER_MIPMAP_MODE_NEAREST", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_MIPMAP_MODE_LINEAR:
            dump_enum<Format>(settings, "VK_SAMPLER_MIPMAP_MODE_LINEAR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorType(const VkDescriptorType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DESCRIPTOR_TYPE_SAMPLER:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_SAMPLER", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_TENSOR_ARM:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_TENSOR_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_MUTABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineBindPoint(const VkPipelineBindPoint object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PIPELINE_BIND_POINT_GRAPHICS:
            dump_enum<Format>(settings, "VK_PIPELINE_BIND_POINT_GRAPHICS", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_BIND_POINT_COMPUTE:
            dump_enum<Format>(settings, "VK_PIPELINE_BIND_POINT_COMPUTE", static_cast<uint32_t>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX:
            dump_enum<Format>(settings, "VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX", static_cast<uint32_t>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS
        case VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR:
            dump_enum<Format>(settings, "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI:
            dump_enum<Format>(settings, "VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM:
            dump_enum<Format>(settings, "VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkBlendFactor(const VkBlendFactor object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_BLEND_FACTOR_ZERO:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_ZERO", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_ONE:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_ONE", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_SRC_COLOR:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_SRC_COLOR", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_DST_COLOR:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_DST_COLOR", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_SRC_ALPHA:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_SRC_ALPHA", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_DST_ALPHA:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_DST_ALPHA", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_CONSTANT_COLOR:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_CONSTANT_COLOR", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_CONSTANT_ALPHA:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_CONSTANT_ALPHA", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_SRC1_COLOR:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_SRC1_COLOR", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_SRC1_ALPHA:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_SRC1_ALPHA", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA:
            dump_enum<Format>(settings, "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkBlendOp(const VkBlendOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_BLEND_OP_ADD:
            dump_enum<Format>(settings, "VK_BLEND_OP_ADD", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_SUBTRACT:
            dump_enum<Format>(settings, "VK_BLEND_OP_SUBTRACT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_REVERSE_SUBTRACT:
            dump_enum<Format>(settings, "VK_BLEND_OP_REVERSE_SUBTRACT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_MIN:
            dump_enum<Format>(settings, "VK_BLEND_OP_MIN", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_MAX:
            dump_enum<Format>(settings, "VK_BLEND_OP_MAX", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_ZERO_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_ZERO_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_SRC_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_SRC_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_DST_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_DST_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_SRC_OVER_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_SRC_OVER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_DST_OVER_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_DST_OVER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_SRC_IN_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_SRC_IN_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_DST_IN_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_DST_IN_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_SRC_OUT_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_SRC_OUT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_DST_OUT_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_DST_OUT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_SRC_ATOP_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_SRC_ATOP_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_DST_ATOP_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_DST_ATOP_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_XOR_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_XOR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_MULTIPLY_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_MULTIPLY_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_SCREEN_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_SCREEN_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_OVERLAY_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_OVERLAY_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_DARKEN_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_DARKEN_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_LIGHTEN_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_LIGHTEN_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_COLORDODGE_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_COLORDODGE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_COLORBURN_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_COLORBURN_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_HARDLIGHT_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_HARDLIGHT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_SOFTLIGHT_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_SOFTLIGHT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_DIFFERENCE_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_DIFFERENCE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_EXCLUSION_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_EXCLUSION_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_INVERT_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_INVERT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_INVERT_RGB_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_INVERT_RGB_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_LINEARDODGE_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_LINEARDODGE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_LINEARBURN_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_LINEARBURN_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_VIVIDLIGHT_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_VIVIDLIGHT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_LINEARLIGHT_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_LINEARLIGHT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_PINLIGHT_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_PINLIGHT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_HARDMIX_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_HARDMIX_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_HSL_HUE_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_HSL_HUE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_HSL_SATURATION_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_HSL_SATURATION_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_HSL_COLOR_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_HSL_COLOR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_HSL_LUMINOSITY_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_PLUS_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_PLUS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_PLUS_CLAMPED_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_PLUS_CLAMPED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_PLUS_DARKER_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_PLUS_DARKER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_MINUS_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_MINUS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_MINUS_CLAMPED_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_MINUS_CLAMPED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_CONTRAST_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_CONTRAST_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_INVERT_OVG_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_INVERT_OVG_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_RED_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_RED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_GREEN_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_GREEN_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OP_BLUE_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OP_BLUE_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDynamicState(const VkDynamicState object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DYNAMIC_STATE_VIEWPORT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_VIEWPORT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_SCISSOR:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_SCISSOR", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_LINE_WIDTH:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_LINE_WIDTH", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DEPTH_BIAS:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DEPTH_BIAS", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_BLEND_CONSTANTS:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_BLEND_CONSTANTS", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DEPTH_BOUNDS:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DEPTH_BOUNDS", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_STENCIL_REFERENCE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_STENCIL_REFERENCE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_CULL_MODE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_CULL_MODE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_FRONT_FACE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_FRONT_FACE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DEPTH_COMPARE_OP:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DEPTH_COMPARE_OP", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_STENCIL_OP:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_STENCIL_OP", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_LINE_STIPPLE:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_LINE_STIPPLE", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_VERTEX_INPUT_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_VERTEX_INPUT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_LOGIC_OP_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_LOGIC_OP_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_POLYGON_MODE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_POLYGON_MODE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_SAMPLE_MASK_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_SAMPLE_MASK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT:
            dump_enum<Format>(settings, "VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkFrontFace(const VkFrontFace object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_FRONT_FACE_COUNTER_CLOCKWISE:
            dump_enum<Format>(settings, "VK_FRONT_FACE_COUNTER_CLOCKWISE", static_cast<uint32_t>(object));
            break;
        case VK_FRONT_FACE_CLOCKWISE:
            dump_enum<Format>(settings, "VK_FRONT_FACE_CLOCKWISE", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkLogicOp(const VkLogicOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_LOGIC_OP_CLEAR:
            dump_enum<Format>(settings, "VK_LOGIC_OP_CLEAR", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_AND:
            dump_enum<Format>(settings, "VK_LOGIC_OP_AND", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_AND_REVERSE:
            dump_enum<Format>(settings, "VK_LOGIC_OP_AND_REVERSE", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_COPY:
            dump_enum<Format>(settings, "VK_LOGIC_OP_COPY", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_AND_INVERTED:
            dump_enum<Format>(settings, "VK_LOGIC_OP_AND_INVERTED", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_NO_OP:
            dump_enum<Format>(settings, "VK_LOGIC_OP_NO_OP", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_XOR:
            dump_enum<Format>(settings, "VK_LOGIC_OP_XOR", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_OR:
            dump_enum<Format>(settings, "VK_LOGIC_OP_OR", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_NOR:
            dump_enum<Format>(settings, "VK_LOGIC_OP_NOR", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_EQUIVALENT:
            dump_enum<Format>(settings, "VK_LOGIC_OP_EQUIVALENT", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_INVERT:
            dump_enum<Format>(settings, "VK_LOGIC_OP_INVERT", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_OR_REVERSE:
            dump_enum<Format>(settings, "VK_LOGIC_OP_OR_REVERSE", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_COPY_INVERTED:
            dump_enum<Format>(settings, "VK_LOGIC_OP_COPY_INVERTED", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_OR_INVERTED:
            dump_enum<Format>(settings, "VK_LOGIC_OP_OR_INVERTED", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_NAND:
            dump_enum<Format>(settings, "VK_LOGIC_OP_NAND", static_cast<uint32_t>(object));
            break;
        case VK_LOGIC_OP_SET:
            dump_enum<Format>(settings, "VK_LOGIC_OP_SET", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkStencilOp(const VkStencilOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_STENCIL_OP_KEEP:
            dump_enum<Format>(settings, "VK_STENCIL_OP_KEEP", static_cast<uint32_t>(object));
            break;
        case VK_STENCIL_OP_ZERO:
            dump_enum<Format>(settings, "VK_STENCIL_OP_ZERO", static_cast<uint32_t>(object));
            break;
        case VK_STENCIL_OP_REPLACE:
            dump_enum<Format>(settings, "VK_STENCIL_OP_REPLACE", static_cast<uint32_t>(object));
            break;
        case VK_STENCIL_OP_INCREMENT_AND_CLAMP:
            dump_enum<Format>(settings, "VK_STENCIL_OP_INCREMENT_AND_CLAMP", static_cast<uint32_t>(object));
            break;
        case VK_STENCIL_OP_DECREMENT_AND_CLAMP:
            dump_enum<Format>(settings, "VK_STENCIL_OP_DECREMENT_AND_CLAMP", static_cast<uint32_t>(object));
            break;
        case VK_STENCIL_OP_INVERT:
            dump_enum<Format>(settings, "VK_STENCIL_OP_INVERT", static_cast<uint32_t>(object));
            break;
        case VK_STENCIL_OP_INCREMENT_AND_WRAP:
            dump_enum<Format>(settings, "VK_STENCIL_OP_INCREMENT_AND_WRAP", static_cast<uint32_t>(object));
            break;
        case VK_STENCIL_OP_DECREMENT_AND_WRAP:
            dump_enum<Format>(settings, "VK_STENCIL_OP_DECREMENT_AND_WRAP", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkVertexInputRate(const VkVertexInputRate object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_VERTEX_INPUT_RATE_VERTEX:
            dump_enum<Format>(settings, "VK_VERTEX_INPUT_RATE_VERTEX", static_cast<uint32_t>(object));
            break;
        case VK_VERTEX_INPUT_RATE_INSTANCE:
            dump_enum<Format>(settings, "VK_VERTEX_INPUT_RATE_INSTANCE", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPrimitiveTopology(const VkPrimitiveTopology object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
            dump_enum<Format>(settings, "VK_PRIMITIVE_TOPOLOGY_POINT_LIST", static_cast<uint32_t>(object));
            break;
        case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
            dump_enum<Format>(settings, "VK_PRIMITIVE_TOPOLOGY_LINE_LIST", static_cast<uint32_t>(object));
            break;
        case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
            dump_enum<Format>(settings, "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP", static_cast<uint32_t>(object));
            break;
        case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
            dump_enum<Format>(settings, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST", static_cast<uint32_t>(object));
            break;
        case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
            dump_enum<Format>(settings, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP", static_cast<uint32_t>(object));
            break;
        case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
            dump_enum<Format>(settings, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN", static_cast<uint32_t>(object));
            break;
        case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
            dump_enum<Format>(settings, "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY", static_cast<uint32_t>(object));
            break;
        case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
            dump_enum<Format>(settings, "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY", static_cast<uint32_t>(object));
            break;
        case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
            dump_enum<Format>(settings, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY", static_cast<uint32_t>(object));
            break;
        case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
            dump_enum<Format>(settings, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY", static_cast<uint32_t>(object));
            break;
        case VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
            dump_enum<Format>(settings, "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPolygonMode(const VkPolygonMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_POLYGON_MODE_FILL:
            dump_enum<Format>(settings, "VK_POLYGON_MODE_FILL", static_cast<uint32_t>(object));
            break;
        case VK_POLYGON_MODE_LINE:
            dump_enum<Format>(settings, "VK_POLYGON_MODE_LINE", static_cast<uint32_t>(object));
            break;
        case VK_POLYGON_MODE_POINT:
            dump_enum<Format>(settings, "VK_POLYGON_MODE_POINT", static_cast<uint32_t>(object));
            break;
        case VK_POLYGON_MODE_FILL_RECTANGLE_NV:
            dump_enum<Format>(settings, "VK_POLYGON_MODE_FILL_RECTANGLE_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentLoadOp(const VkAttachmentLoadOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_ATTACHMENT_LOAD_OP_LOAD:
            dump_enum<Format>(settings, "VK_ATTACHMENT_LOAD_OP_LOAD", static_cast<uint32_t>(object));
            break;
        case VK_ATTACHMENT_LOAD_OP_CLEAR:
            dump_enum<Format>(settings, "VK_ATTACHMENT_LOAD_OP_CLEAR", static_cast<uint32_t>(object));
            break;
        case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
            dump_enum<Format>(settings, "VK_ATTACHMENT_LOAD_OP_DONT_CARE", static_cast<uint32_t>(object));
            break;
        case VK_ATTACHMENT_LOAD_OP_NONE:
            dump_enum<Format>(settings, "VK_ATTACHMENT_LOAD_OP_NONE", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentStoreOp(const VkAttachmentStoreOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_ATTACHMENT_STORE_OP_STORE:
            dump_enum<Format>(settings, "VK_ATTACHMENT_STORE_OP_STORE", static_cast<uint32_t>(object));
            break;
        case VK_ATTACHMENT_STORE_OP_DONT_CARE:
            dump_enum<Format>(settings, "VK_ATTACHMENT_STORE_OP_DONT_CARE", static_cast<uint32_t>(object));
            break;
        case VK_ATTACHMENT_STORE_OP_NONE:
            dump_enum<Format>(settings, "VK_ATTACHMENT_STORE_OP_NONE", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubpassContents(const VkSubpassContents object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SUBPASS_CONTENTS_INLINE:
            dump_enum<Format>(settings, "VK_SUBPASS_CONTENTS_INLINE", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS:
            dump_enum<Format>(settings, "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR:
            dump_enum<Format>(settings, "VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPointClippingBehavior(const VkPointClippingBehavior object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES:
            dump_enum<Format>(settings, "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES", static_cast<uint32_t>(object));
            break;
        case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY:
            dump_enum<Format>(settings, "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorUpdateTemplateType(const VkDescriptorUpdateTemplateType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
            dump_enum<Format>(settings, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
            dump_enum<Format>(settings, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709:
            dump_enum<Format>(settings, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601:
            dump_enum<Format>(settings, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020:
            dump_enum<Format>(settings, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerYcbcrRange(const VkSamplerYcbcrRange object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SAMPLER_YCBCR_RANGE_ITU_FULL:
            dump_enum<Format>(settings, "VK_SAMPLER_YCBCR_RANGE_ITU_FULL", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_YCBCR_RANGE_ITU_NARROW:
            dump_enum<Format>(settings, "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkChromaLocation(const VkChromaLocation object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_CHROMA_LOCATION_COSITED_EVEN:
            dump_enum<Format>(settings, "VK_CHROMA_LOCATION_COSITED_EVEN", static_cast<uint32_t>(object));
            break;
        case VK_CHROMA_LOCATION_MIDPOINT:
            dump_enum<Format>(settings, "VK_CHROMA_LOCATION_MIDPOINT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkTessellationDomainOrigin(const VkTessellationDomainOrigin object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT:
            dump_enum<Format>(settings, "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT", static_cast<uint32_t>(object));
            break;
        case VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT:
            dump_enum<Format>(settings, "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDriverId(const VkDriverId object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DRIVER_ID_AMD_PROPRIETARY:
            dump_enum<Format>(settings, "VK_DRIVER_ID_AMD_PROPRIETARY", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_AMD_OPEN_SOURCE:
            dump_enum<Format>(settings, "VK_DRIVER_ID_AMD_OPEN_SOURCE", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MESA_RADV:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MESA_RADV", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_NVIDIA_PROPRIETARY:
            dump_enum<Format>(settings, "VK_DRIVER_ID_NVIDIA_PROPRIETARY", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS:
            dump_enum<Format>(settings, "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA:
            dump_enum<Format>(settings, "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_IMAGINATION_PROPRIETARY:
            dump_enum<Format>(settings, "VK_DRIVER_ID_IMAGINATION_PROPRIETARY", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_QUALCOMM_PROPRIETARY:
            dump_enum<Format>(settings, "VK_DRIVER_ID_QUALCOMM_PROPRIETARY", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_ARM_PROPRIETARY:
            dump_enum<Format>(settings, "VK_DRIVER_ID_ARM_PROPRIETARY", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_GOOGLE_SWIFTSHADER:
            dump_enum<Format>(settings, "VK_DRIVER_ID_GOOGLE_SWIFTSHADER", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_GGP_PROPRIETARY:
            dump_enum<Format>(settings, "VK_DRIVER_ID_GGP_PROPRIETARY", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_BROADCOM_PROPRIETARY:
            dump_enum<Format>(settings, "VK_DRIVER_ID_BROADCOM_PROPRIETARY", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MESA_LLVMPIPE:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MESA_LLVMPIPE", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MOLTENVK:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MOLTENVK", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_COREAVI_PROPRIETARY:
            dump_enum<Format>(settings, "VK_DRIVER_ID_COREAVI_PROPRIETARY", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_JUICE_PROPRIETARY:
            dump_enum<Format>(settings, "VK_DRIVER_ID_JUICE_PROPRIETARY", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_VERISILICON_PROPRIETARY:
            dump_enum<Format>(settings, "VK_DRIVER_ID_VERISILICON_PROPRIETARY", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MESA_TURNIP:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MESA_TURNIP", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MESA_V3DV:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MESA_V3DV", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MESA_PANVK:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MESA_PANVK", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_SAMSUNG_PROPRIETARY:
            dump_enum<Format>(settings, "VK_DRIVER_ID_SAMSUNG_PROPRIETARY", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MESA_VENUS:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MESA_VENUS", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MESA_DOZEN:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MESA_DOZEN", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MESA_NVK:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MESA_NVK", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA:
            dump_enum<Format>(settings, "VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MESA_HONEYKRISP:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MESA_HONEYKRISP", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN:
            dump_enum<Format>(settings, "VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MESA_KOSMICKRISP:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MESA_KOSMICKRISP", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_MESA_GFXSTREAM:
            dump_enum<Format>(settings, "VK_DRIVER_ID_MESA_GFXSTREAM", static_cast<uint32_t>(object));
            break;
        case VK_DRIVER_ID_APE_SOFT:
            dump_enum<Format>(settings, "VK_DRIVER_ID_APE_SOFT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY:
            dump_enum<Format>(settings, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY", static_cast<uint32_t>(object));
            break;
        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL:
            dump_enum<Format>(settings, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL", static_cast<uint32_t>(object));
            break;
        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE:
            dump_enum<Format>(settings, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreType(const VkSemaphoreType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SEMAPHORE_TYPE_BINARY:
            dump_enum<Format>(settings, "VK_SEMAPHORE_TYPE_BINARY", static_cast<uint32_t>(object));
            break;
        case VK_SEMAPHORE_TYPE_TIMELINE:
            dump_enum<Format>(settings, "VK_SEMAPHORE_TYPE_TIMELINE", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerReductionMode(const VkSamplerReductionMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE:
            dump_enum<Format>(settings, "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_REDUCTION_MODE_MIN:
            dump_enum<Format>(settings, "VK_SAMPLER_REDUCTION_MODE_MIN", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_REDUCTION_MODE_MAX:
            dump_enum<Format>(settings, "VK_SAMPLER_REDUCTION_MODE_MAX", static_cast<uint32_t>(object));
            break;
        case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM:
            dump_enum<Format>(settings, "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRobustnessBufferBehavior(const VkPipelineRobustnessBufferBehavior object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT:
            dump_enum<Format>(settings, "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED:
            dump_enum<Format>(settings, "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS:
            dump_enum<Format>(settings, "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2:
            dump_enum<Format>(settings, "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRobustnessImageBehavior(const VkPipelineRobustnessImageBehavior object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT:
            dump_enum<Format>(settings, "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED:
            dump_enum<Format>(settings, "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS:
            dump_enum<Format>(settings, "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2:
            dump_enum<Format>(settings, "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueGlobalPriority(const VkQueueGlobalPriority object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_QUEUE_GLOBAL_PRIORITY_LOW:
            dump_enum<Format>(settings, "VK_QUEUE_GLOBAL_PRIORITY_LOW", static_cast<uint32_t>(object));
            break;
        case VK_QUEUE_GLOBAL_PRIORITY_MEDIUM:
            dump_enum<Format>(settings, "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM", static_cast<uint32_t>(object));
            break;
        case VK_QUEUE_GLOBAL_PRIORITY_HIGH:
            dump_enum<Format>(settings, "VK_QUEUE_GLOBAL_PRIORITY_HIGH", static_cast<uint32_t>(object));
            break;
        case VK_QUEUE_GLOBAL_PRIORITY_REALTIME:
            dump_enum<Format>(settings, "VK_QUEUE_GLOBAL_PRIORITY_REALTIME", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkLineRasterizationMode(const VkLineRasterizationMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_LINE_RASTERIZATION_MODE_DEFAULT:
            dump_enum<Format>(settings, "VK_LINE_RASTERIZATION_MODE_DEFAULT", static_cast<uint32_t>(object));
            break;
        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR:
            dump_enum<Format>(settings, "VK_LINE_RASTERIZATION_MODE_RECTANGULAR", static_cast<uint32_t>(object));
            break;
        case VK_LINE_RASTERIZATION_MODE_BRESENHAM:
            dump_enum<Format>(settings, "VK_LINE_RASTERIZATION_MODE_BRESENHAM", static_cast<uint32_t>(object));
            break;
        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH:
            dump_enum<Format>(settings, "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentModeKHR(const VkPresentModeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PRESENT_MODE_IMMEDIATE_KHR:
            dump_enum<Format>(settings, "VK_PRESENT_MODE_IMMEDIATE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PRESENT_MODE_MAILBOX_KHR:
            dump_enum<Format>(settings, "VK_PRESENT_MODE_MAILBOX_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PRESENT_MODE_FIFO_KHR:
            dump_enum<Format>(settings, "VK_PRESENT_MODE_FIFO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
            dump_enum<Format>(settings, "VK_PRESENT_MODE_FIFO_RELAXED_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR:
            dump_enum<Format>(settings, "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR:
            dump_enum<Format>(settings, "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PRESENT_MODE_FIFO_LATEST_READY_KHR:
            dump_enum<Format>(settings, "VK_PRESENT_MODE_FIFO_LATEST_READY_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkColorSpaceKHR(const VkColorSpaceKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_BT709_LINEAR_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_BT709_LINEAR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_BT709_NONLINEAR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_BT2020_LINEAR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_HDR10_ST2084_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_HDR10_ST2084_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_DOLBYVISION_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_DOLBYVISION_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_HDR10_HLG_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_HDR10_HLG_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_PASS_THROUGH_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_PASS_THROUGH_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COLOR_SPACE_DISPLAY_NATIVE_AMD:
            dump_enum<Format>(settings, "VK_COLOR_SPACE_DISPLAY_NATIVE_AMD", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueryResultStatusKHR(const VkQueryResultStatusKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_QUERY_RESULT_STATUS_ERROR_KHR:
            dump_enum<Format>(settings, "VK_QUERY_RESULT_STATUS_ERROR_KHR", static_cast<int32_t>(object));
            break;
        case VK_QUERY_RESULT_STATUS_NOT_READY_KHR:
            dump_enum<Format>(settings, "VK_QUERY_RESULT_STATUS_NOT_READY_KHR", static_cast<int32_t>(object));
            break;
        case VK_QUERY_RESULT_STATUS_COMPLETE_KHR:
            dump_enum<Format>(settings, "VK_QUERY_RESULT_STATUS_COMPLETE_KHR", static_cast<int32_t>(object));
            break;
        case VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR:
            dump_enum<Format>(settings, "VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR", static_cast<int32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<int32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceCounterUnitKHR(const VkPerformanceCounterUnitKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceCounterScopeKHR(const VkPerformanceCounterScopeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceCounterStorageKHR(const VkPerformanceCounterStorageKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR:
            dump_enum<Format>(settings, "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkFragmentShadingRateCombinerOpKHR(const VkFragmentShadingRateCombinerOpKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineExecutableStatisticFormatKHR(const VkPipelineExecutableStatisticFormatKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR:
            dump_enum<Format>(settings, "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR:
            dump_enum<Format>(settings, "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR:
            dump_enum<Format>(settings, "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR:
            dump_enum<Format>(settings, "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeTuningModeKHR(const VkVideoEncodeTuningModeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR", static_cast<uint32_t>(object));
            break;
        case VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureTypeKHR(const VkAccelerationStructureTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR", static_cast<uint32_t>(object));
            break;
        case VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR", static_cast<uint32_t>(object));
            break;
        case VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR", static_cast<uint32_t>(object));
            break;
        case VK_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_KHR:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkComponentTypeKHR(const VkComponentTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COMPONENT_TYPE_FLOAT16_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_FLOAT16_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_FLOAT32_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_FLOAT32_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_FLOAT64_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_FLOAT64_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_SINT8_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_SINT8_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_SINT16_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_SINT16_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_SINT32_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_SINT32_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_SINT64_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_SINT64_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_UINT8_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_UINT8_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_UINT16_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_UINT16_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_UINT32_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_UINT32_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_UINT64_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_UINT64_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_BFLOAT16_KHR:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_BFLOAT16_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_SINT8_PACKED_NV:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_SINT8_PACKED_NV", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_UINT8_PACKED_NV:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_UINT8_PACKED_NV", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_FLOAT6_E2M3_EXT:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_FLOAT6_E2M3_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_FLOAT6_E3M2_EXT:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_FLOAT6_E3M2_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_FLOAT4_E2M1_EXT:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_FLOAT4_E2M1_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_FLOAT8_UNSIGNED_E8M0_EXT:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_FLOAT8_UNSIGNED_E8M0_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COMPONENT_TYPE_MXINT8_EXT:
            dump_enum<Format>(settings, "VK_COMPONENT_TYPE_MXINT8_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkScopeKHR(const VkScopeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SCOPE_DEVICE_KHR:
            dump_enum<Format>(settings, "VK_SCOPE_DEVICE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_SCOPE_WORKGROUP_KHR:
            dump_enum<Format>(settings, "VK_SCOPE_WORKGROUP_KHR", static_cast<uint32_t>(object));
            break;
        case VK_SCOPE_SUBGROUP_KHR:
            dump_enum<Format>(settings, "VK_SCOPE_SUBGROUP_KHR", static_cast<uint32_t>(object));
            break;
        case VK_SCOPE_QUEUE_FAMILY_KHR:
            dump_enum<Format>(settings, "VK_SCOPE_QUEUE_FAMILY_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1PredictionModeKHR(const VkVideoEncodeAV1PredictionModeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR", static_cast<uint32_t>(object));
            break;
        case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR", static_cast<uint32_t>(object));
            break;
        case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1RateControlGroupKHR(const VkVideoEncodeAV1RateControlGroupKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR", static_cast<uint32_t>(object));
            break;
        case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR:
            dump_enum<Format>(settings, "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkTimeDomainKHR(const VkTimeDomainKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_TIME_DOMAIN_DEVICE_KHR:
            dump_enum<Format>(settings, "VK_TIME_DOMAIN_DEVICE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR:
            dump_enum<Format>(settings, "VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR", static_cast<uint32_t>(object));
            break;
        case VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR:
            dump_enum<Format>(settings, "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR", static_cast<uint32_t>(object));
            break;
        case VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR:
            dump_enum<Format>(settings, "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR", static_cast<uint32_t>(object));
            break;
        case VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT:
            dump_enum<Format>(settings, "VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT", static_cast<uint32_t>(object));
            break;
        case VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT:
            dump_enum<Format>(settings, "VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLayeredApiKHR(const VkPhysicalDeviceLayeredApiKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceFaultAddressTypeKHR(const VkDeviceFaultAddressTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_KHR:
            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_KHR:
            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_KHR", static_cast<uint32_t>(object));
            break;
        case VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_KHR:
            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_KHR", static_cast<uint32_t>(object));
            break;
        case VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_KHR:
            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_KHR", static_cast<uint32_t>(object));
            break;
        case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_KHR:
            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_KHR", static_cast<uint32_t>(object));
            break;
        case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_KHR:
            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_KHR", static_cast<uint32_t>(object));
            break;
        case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_KHR:
            dump_enum<Format>(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceFaultVendorBinaryHeaderVersionKHR(const VkDeviceFaultVendorBinaryHeaderVersionKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_KHR:
            dump_enum<Format>(settings, "VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDefaultVertexAttributeValueKHR(const VkDefaultVertexAttributeValueKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR:
            dump_enum<Format>(settings, "VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR", static_cast<uint32_t>(object));
            break;
        case VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR:
            dump_enum<Format>(settings, "VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkOpacityMicromapFormatKHR(const VkOpacityMicromapFormatKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_OPACITY_MICROMAP_FORMAT_2_STATE_KHR:
            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_FORMAT_2_STATE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OPACITY_MICROMAP_FORMAT_4_STATE_KHR:
            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_FORMAT_4_STATE_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkOpacityMicromapSpecialIndexKHR(const VkOpacityMicromapSpecialIndexKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_KHR:
            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_KHR:
            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_KHR:
            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_KHR:
            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV:
            dump_enum<Format>(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureSerializedBlockTypeKHR(const VkAccelerationStructureSerializedBlockTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_ACCELERATION_STRUCTURE_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAP_KHR:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAP_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDebugReportObjectTypeEXT(const VkDebugReportObjectTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT:
            dump_enum<Format>(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkRasterizationOrderAMD(const VkRasterizationOrderAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_RASTERIZATION_ORDER_STRICT_AMD:
            dump_enum<Format>(settings, "VK_RASTERIZATION_ORDER_STRICT_AMD", static_cast<uint32_t>(object));
            break;
        case VK_RASTERIZATION_ORDER_RELAXED_AMD:
            dump_enum<Format>(settings, "VK_RASTERIZATION_ORDER_RELAXED_AMD", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderInfoTypeAMD(const VkShaderInfoTypeAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SHADER_INFO_TYPE_STATISTICS_AMD:
            dump_enum<Format>(settings, "VK_SHADER_INFO_TYPE_STATISTICS_AMD", static_cast<uint32_t>(object));
            break;
        case VK_SHADER_INFO_TYPE_BINARY_AMD:
            dump_enum<Format>(settings, "VK_SHADER_INFO_TYPE_BINARY_AMD", static_cast<uint32_t>(object));
            break;
        case VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD:
            dump_enum<Format>(settings, "VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkValidationCheckEXT(const VkValidationCheckEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_VALIDATION_CHECK_ALL_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_CHECK_ALL_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_CHECK_SHADERS_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_CHECK_SHADERS_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayPowerStateEXT(const VkDisplayPowerStateEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DISPLAY_POWER_STATE_OFF_EXT:
            dump_enum<Format>(settings, "VK_DISPLAY_POWER_STATE_OFF_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DISPLAY_POWER_STATE_SUSPEND_EXT:
            dump_enum<Format>(settings, "VK_DISPLAY_POWER_STATE_SUSPEND_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DISPLAY_POWER_STATE_ON_EXT:
            dump_enum<Format>(settings, "VK_DISPLAY_POWER_STATE_ON_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceEventTypeEXT(const VkDeviceEventTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT:
            dump_enum<Format>(settings, "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayEventTypeEXT(const VkDisplayEventTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT:
            dump_enum<Format>(settings, "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkViewportCoordinateSwizzleNV(const VkViewportCoordinateSwizzleNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV:
            dump_enum<Format>(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV", static_cast<uint32_t>(object));
            break;
        case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV:
            dump_enum<Format>(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV", static_cast<uint32_t>(object));
            break;
        case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV:
            dump_enum<Format>(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV", static_cast<uint32_t>(object));
            break;
        case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV:
            dump_enum<Format>(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV", static_cast<uint32_t>(object));
            break;
        case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV:
            dump_enum<Format>(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV", static_cast<uint32_t>(object));
            break;
        case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV:
            dump_enum<Format>(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV", static_cast<uint32_t>(object));
            break;
        case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV:
            dump_enum<Format>(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV", static_cast<uint32_t>(object));
            break;
        case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV:
            dump_enum<Format>(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDiscardRectangleModeEXT(const VkDiscardRectangleModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT:
            dump_enum<Format>(settings, "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT:
            dump_enum<Format>(settings, "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkConservativeRasterizationModeEXT(const VkConservativeRasterizationModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT:
            dump_enum<Format>(settings, "VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT:
            dump_enum<Format>(settings, "VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT:
            dump_enum<Format>(settings, "VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkGpaPerfBlockAMD(const VkGpaPerfBlockAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_GPA_PERF_BLOCK_CPF_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_CPF_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_IA_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_IA_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_VGT_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_VGT_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_PA_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_PA_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_SC_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_SC_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_SPI_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_SPI_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_SQ_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_SQ_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_SX_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_SX_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_TA_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_TA_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_TD_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_TD_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_TCP_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_TCP_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_TCC_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_TCC_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_TCA_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_TCA_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_DB_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_DB_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_CB_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_CB_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GDS_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GDS_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_SRBM_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_SRBM_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GRBM_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GRBM_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GRBM_SE_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GRBM_SE_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_RLC_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_RLC_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_DMA_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_DMA_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_MC_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_MC_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_CPG_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_CPG_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_CPC_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_CPC_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_WD_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_WD_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_TCS_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_TCS_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_ATC_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_ATC_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_ATC_L2_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_ATC_L2_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_MC_VM_L2_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_MC_VM_L2_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_EA_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_EA_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_RPB_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_RPB_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_RMI_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_RMI_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_UMCCH_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_UMCCH_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GE_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GE_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GL1A_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GL1A_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GL1C_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GL1C_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GL1CG_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GL1CG_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GL2A_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GL2A_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GL2C_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GL2C_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_CHA_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_CHA_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_CHC_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_CHC_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_CHCG_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_CHCG_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GUS_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GUS_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GCR_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GCR_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_PH_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_PH_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_UTCL1_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_UTCL1_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GE_DIST_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GE_DIST_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GE_SE_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GE_SE_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_DF_MALL_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_DF_MALL_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_SQ_WGP_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_SQ_WGP_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_PC_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_PC_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GL1XA_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GL1XA_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_GL1XC_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_GL1XC_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_WGS_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_WGS_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_EACPWD_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_EACPWD_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_EASE_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_EASE_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_PERF_BLOCK_RLCUSER_AMD:
            dump_enum<Format>(settings, "VK_GPA_PERF_BLOCK_RLCUSER_AMD", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkGpaSampleTypeAMD(const VkGpaSampleTypeAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_GPA_SAMPLE_TYPE_CUMULATIVE_AMD:
            dump_enum<Format>(settings, "VK_GPA_SAMPLE_TYPE_CUMULATIVE_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_SAMPLE_TYPE_TRACE_AMD:
            dump_enum<Format>(settings, "VK_GPA_SAMPLE_TYPE_TRACE_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_SAMPLE_TYPE_TIMING_AMD:
            dump_enum<Format>(settings, "VK_GPA_SAMPLE_TYPE_TIMING_AMD", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkGpaDeviceClockModeAMD(const VkGpaDeviceClockModeAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_GPA_DEVICE_CLOCK_MODE_DEFAULT_AMD:
            dump_enum<Format>(settings, "VK_GPA_DEVICE_CLOCK_MODE_DEFAULT_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_DEVICE_CLOCK_MODE_QUERY_AMD:
            dump_enum<Format>(settings, "VK_GPA_DEVICE_CLOCK_MODE_QUERY_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_DEVICE_CLOCK_MODE_PROFILING_AMD:
            dump_enum<Format>(settings, "VK_GPA_DEVICE_CLOCK_MODE_PROFILING_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_DEVICE_CLOCK_MODE_MIN_MEMORY_AMD:
            dump_enum<Format>(settings, "VK_GPA_DEVICE_CLOCK_MODE_MIN_MEMORY_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_DEVICE_CLOCK_MODE_MIN_ENGINE_AMD:
            dump_enum<Format>(settings, "VK_GPA_DEVICE_CLOCK_MODE_MIN_ENGINE_AMD", static_cast<uint32_t>(object));
            break;
        case VK_GPA_DEVICE_CLOCK_MODE_PEAK_AMD:
            dump_enum<Format>(settings, "VK_GPA_DEVICE_CLOCK_MODE_PEAK_AMD", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorMappingSourceEXT(const VkDescriptorMappingSourceEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT:
            dump_enum<Format>(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkBlendOverlapEXT(const VkBlendOverlapEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_BLEND_OVERLAP_UNCORRELATED_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OVERLAP_UNCORRELATED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OVERLAP_DISJOINT_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OVERLAP_DISJOINT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_BLEND_OVERLAP_CONJOINT_EXT:
            dump_enum<Format>(settings, "VK_BLEND_OVERLAP_CONJOINT_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkCoverageModulationModeNV(const VkCoverageModulationModeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COVERAGE_MODULATION_MODE_NONE_NV:
            dump_enum<Format>(settings, "VK_COVERAGE_MODULATION_MODE_NONE_NV", static_cast<uint32_t>(object));
            break;
        case VK_COVERAGE_MODULATION_MODE_RGB_NV:
            dump_enum<Format>(settings, "VK_COVERAGE_MODULATION_MODE_RGB_NV", static_cast<uint32_t>(object));
            break;
        case VK_COVERAGE_MODULATION_MODE_ALPHA_NV:
            dump_enum<Format>(settings, "VK_COVERAGE_MODULATION_MODE_ALPHA_NV", static_cast<uint32_t>(object));
            break;
        case VK_COVERAGE_MODULATION_MODE_RGBA_NV:
            dump_enum<Format>(settings, "VK_COVERAGE_MODULATION_MODE_RGBA_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkValidationCacheHeaderVersionEXT(const VkValidationCacheHeaderVersionEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkShadingRatePaletteEntryNV(const VkShadingRatePaletteEntryNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV", static_cast<uint32_t>(object));
            break;
        case VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV:
            dump_enum<Format>(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkCoarseSampleOrderTypeNV(const VkCoarseSampleOrderTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV:
            dump_enum<Format>(settings, "VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV", static_cast<uint32_t>(object));
            break;
        case VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV:
            dump_enum<Format>(settings, "VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV", static_cast<uint32_t>(object));
            break;
        case VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV:
            dump_enum<Format>(settings, "VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV", static_cast<uint32_t>(object));
            break;
        case VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV:
            dump_enum<Format>(settings, "VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkRayTracingShaderGroupTypeKHR(const VkRayTracingShaderGroupTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR:
            dump_enum<Format>(settings, "VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR", static_cast<uint32_t>(object));
            break;
        case VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR:
            dump_enum<Format>(settings, "VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR", static_cast<uint32_t>(object));
            break;
        case VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR:
            dump_enum<Format>(settings, "VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeometryTypeKHR(const VkGeometryTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_GEOMETRY_TYPE_TRIANGLES_KHR:
            dump_enum<Format>(settings, "VK_GEOMETRY_TYPE_TRIANGLES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_GEOMETRY_TYPE_AABBS_KHR:
            dump_enum<Format>(settings, "VK_GEOMETRY_TYPE_AABBS_KHR", static_cast<uint32_t>(object));
            break;
        case VK_GEOMETRY_TYPE_INSTANCES_KHR:
            dump_enum<Format>(settings, "VK_GEOMETRY_TYPE_INSTANCES_KHR", static_cast<uint32_t>(object));
            break;
        case VK_GEOMETRY_TYPE_SPHERES_NV:
            dump_enum<Format>(settings, "VK_GEOMETRY_TYPE_SPHERES_NV", static_cast<uint32_t>(object));
            break;
        case VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV:
            dump_enum<Format>(settings, "VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV", static_cast<uint32_t>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX:
            dump_enum<Format>(settings, "VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX", static_cast<uint32_t>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS
        case VK_GEOMETRY_TYPE_MICROMAP_KHR:
            dump_enum<Format>(settings, "VK_GEOMETRY_TYPE_MICROMAP_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyAccelerationStructureModeKHR(const VkCopyAccelerationStructureModeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR:
            dump_enum<Format>(settings, "VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR:
            dump_enum<Format>(settings, "VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR:
            dump_enum<Format>(settings, "VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR:
            dump_enum<Format>(settings, "VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureMemoryRequirementsTypeNV(const VkAccelerationStructureMemoryRequirementsTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV", static_cast<uint32_t>(object));
            break;
        case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV", static_cast<uint32_t>(object));
            break;
        case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryOverallocationBehaviorAMD(const VkMemoryOverallocationBehaviorAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD:
            dump_enum<Format>(settings, "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD", static_cast<uint32_t>(object));
            break;
        case VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD:
            dump_enum<Format>(settings, "VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD", static_cast<uint32_t>(object));
            break;
        case VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD:
            dump_enum<Format>(settings, "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceConfigurationTypeINTEL(const VkPerformanceConfigurationTypeINTEL object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL:
            dump_enum<Format>(settings, "VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueryPoolSamplingModeINTEL(const VkQueryPoolSamplingModeINTEL object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL:
            dump_enum<Format>(settings, "VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceOverrideTypeINTEL(const VkPerformanceOverrideTypeINTEL object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL:
            dump_enum<Format>(settings, "VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL:
            dump_enum<Format>(settings, "VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceParameterTypeINTEL(const VkPerformanceParameterTypeINTEL object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL:
            dump_enum<Format>(settings, "VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL:
            dump_enum<Format>(settings, "VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceValueTypeINTEL(const VkPerformanceValueTypeINTEL object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL:
            dump_enum<Format>(settings, "VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL:
            dump_enum<Format>(settings, "VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL:
            dump_enum<Format>(settings, "VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL:
            dump_enum<Format>(settings, "VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL", static_cast<uint32_t>(object));
            break;
        case VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL:
            dump_enum<Format>(settings, "VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkValidationFeatureEnableEXT(const VkValidationFeatureEnableEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkValidationFeatureDisableEXT(const VkValidationFeatureDisableEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_VALIDATION_FEATURE_DISABLE_ALL_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_DISABLE_ALL_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT:
            dump_enum<Format>(settings, "VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkCoverageReductionModeNV(const VkCoverageReductionModeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COVERAGE_REDUCTION_MODE_MERGE_NV:
            dump_enum<Format>(settings, "VK_COVERAGE_REDUCTION_MODE_MERGE_NV", static_cast<uint32_t>(object));
            break;
        case VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV:
            dump_enum<Format>(settings, "VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkProvokingVertexModeEXT(const VkProvokingVertexModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT:
            dump_enum<Format>(settings, "VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT", static_cast<uint32_t>(object));
            break;
        case VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT:
            dump_enum<Format>(settings, "VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
template <ApiDumpFormat Format>
void dump_VkFullScreenExclusiveEXT(const VkFullScreenExclusiveEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT:
            dump_enum<Format>(settings, "VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT:
            dump_enum<Format>(settings, "VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT:
            dump_enum<Format>(settings, "VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT:
            dump_enum<Format>(settings, "VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsTokenTypeNV(const VkIndirectCommandsTokenTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDepthBiasRepresentationEXT(const VkDepthBiasRepresentationEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT:
            dump_enum<Format>(settings, "VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT:
            dump_enum<Format>(settings, "VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT:
            dump_enum<Format>(settings, "VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceMemoryReportEventTypeEXT(const VkDeviceMemoryReportEventTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT:
            dump_enum<Format>(settings, "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT:
            dump_enum<Format>(settings, "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT:
            dump_enum<Format>(settings, "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT:
            dump_enum<Format>(settings, "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT:
            dump_enum<Format>(settings, "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerfHintTypeQCOM(const VkPerfHintTypeQCOM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PERF_HINT_TYPE_DEFAULT_QCOM:
            dump_enum<Format>(settings, "VK_PERF_HINT_TYPE_DEFAULT_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_PERF_HINT_TYPE_FREQUENCY_MIN_QCOM:
            dump_enum<Format>(settings, "VK_PERF_HINT_TYPE_FREQUENCY_MIN_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_PERF_HINT_TYPE_FREQUENCY_MAX_QCOM:
            dump_enum<Format>(settings, "VK_PERF_HINT_TYPE_FREQUENCY_MAX_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_PERF_HINT_TYPE_FREQUENCY_SCALED_QCOM:
            dump_enum<Format>(settings, "VK_PERF_HINT_TYPE_FREQUENCY_SCALED_QCOM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkFragmentShadingRateTypeNV(const VkFragmentShadingRateTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkFragmentShadingRateNV(const VkFragmentShadingRateNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV:
            dump_enum<Format>(settings, "VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureMotionInstanceTypeNV(const VkAccelerationStructureMotionInstanceTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV", static_cast<uint32_t>(object));
            break;
        case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV", static_cast<uint32_t>(object));
            break;
        case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceAddressBindingTypeEXT(const VkDeviceAddressBindingTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT:
            dump_enum<Format>(settings, "VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT:
            dump_enum<Format>(settings, "VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkMicromapTypeEXT(const VkMicromapTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT:
            dump_enum<Format>(settings, "VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT", static_cast<uint32_t>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV:
            dump_enum<Format>(settings, "VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV", static_cast<uint32_t>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkBuildMicromapModeEXT(const VkBuildMicromapModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_BUILD_MICROMAP_MODE_BUILD_EXT:
            dump_enum<Format>(settings, "VK_BUILD_MICROMAP_MODE_BUILD_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyMicromapModeEXT(const VkCopyMicromapModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COPY_MICROMAP_MODE_CLONE_EXT:
            dump_enum<Format>(settings, "VK_COPY_MICROMAP_MODE_CLONE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COPY_MICROMAP_MODE_SERIALIZE_EXT:
            dump_enum<Format>(settings, "VK_COPY_MICROMAP_MODE_SERIALIZE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT:
            dump_enum<Format>(settings, "VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_COPY_MICROMAP_MODE_COMPACT_EXT:
            dump_enum<Format>(settings, "VK_COPY_MICROMAP_MODE_COMPACT_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureCompatibilityKHR(const VkAccelerationStructureCompatibilityKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureBuildTypeKHR(const VkAccelerationStructureBuildTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR", static_cast<uint32_t>(object));
            break;
        case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR", static_cast<uint32_t>(object));
            break;
        case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR:
            dump_enum<Format>(settings, "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
template <ApiDumpFormat Format>
void dump_VkDisplacementMicromapFormatNV(const VkDisplacementMicromapFormatNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV:
            dump_enum<Format>(settings, "VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV", static_cast<uint32_t>(object));
            break;
        case VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV:
            dump_enum<Format>(settings, "VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV", static_cast<uint32_t>(object));
            break;
        case VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV:
            dump_enum<Format>(settings, "VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_ENABLE_BETA_EXTENSIONS
template <ApiDumpFormat Format>
void dump_VkRayTracingLssIndexingModeNV(const VkRayTracingLssIndexingModeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV:
            dump_enum<Format>(settings, "VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV", static_cast<uint32_t>(object));
            break;
        case VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV:
            dump_enum<Format>(settings, "VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkRayTracingLssPrimitiveEndCapsModeNV(const VkRayTracingLssPrimitiveEndCapsModeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV:
            dump_enum<Format>(settings, "VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV", static_cast<uint32_t>(object));
            break;
        case VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV:
            dump_enum<Format>(settings, "VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubpassMergeStatusEXT(const VkSubpassMergeStatusEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SUBPASS_MERGE_STATUS_MERGED_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_MERGED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT:
            dump_enum<Format>(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDirectDriverLoadingModeLUNARG(const VkDirectDriverLoadingModeLUNARG object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG:
            dump_enum<Format>(settings, "VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG", static_cast<uint32_t>(object));
            break;
        case VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG:
            dump_enum<Format>(settings, "VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorTilingARM(const VkTensorTilingARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_TENSOR_TILING_OPTIMAL_ARM:
            dump_enum<Format>(settings, "VK_TENSOR_TILING_OPTIMAL_ARM", static_cast<uint32_t>(object));
            break;
        case VK_TENSOR_TILING_LINEAR_ARM:
            dump_enum<Format>(settings, "VK_TENSOR_TILING_LINEAR_ARM", static_cast<uint32_t>(object));
            break;
        case VK_TENSOR_TILING_BRICK_16_WIDE_ARM:
            dump_enum<Format>(settings, "VK_TENSOR_TILING_BRICK_16_WIDE_ARM", static_cast<uint32_t>(object));
            break;
        case VK_TENSOR_TILING_BRICK_8_WIDE_ARM:
            dump_enum<Format>(settings, "VK_TENSOR_TILING_BRICK_8_WIDE_ARM", static_cast<uint32_t>(object));
            break;
        case VK_TENSOR_TILING_BRICK_4_WIDE_ARM:
            dump_enum<Format>(settings, "VK_TENSOR_TILING_BRICK_4_WIDE_ARM", static_cast<uint32_t>(object));
            break;
        case VK_TENSOR_TILING_BLOCK_U_INTERLEAVED_ARM:
            dump_enum<Format>(settings, "VK_TENSOR_TILING_BLOCK_U_INTERLEAVED_ARM", static_cast<uint32_t>(object));
            break;
        case VK_TENSOR_TILING_BLOCK_U_INTERLEAVED_64K_ARM:
            dump_enum<Format>(settings, "VK_TENSOR_TILING_BLOCK_U_INTERLEAVED_64K_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkOpticalFlowPerformanceLevelNV(const VkOpticalFlowPerformanceLevelNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV", static_cast<uint32_t>(object));
            break;
        case VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV", static_cast<uint32_t>(object));
            break;
        case VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV", static_cast<uint32_t>(object));
            break;
        case VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkOpticalFlowSessionBindingPointNV(const VkOpticalFlowSessionBindingPointNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV", static_cast<uint32_t>(object));
            break;
        case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV", static_cast<uint32_t>(object));
            break;
        case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV", static_cast<uint32_t>(object));
            break;
        case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV", static_cast<uint32_t>(object));
            break;
        case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV", static_cast<uint32_t>(object));
            break;
        case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV", static_cast<uint32_t>(object));
            break;
        case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV", static_cast<uint32_t>(object));
            break;
        case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV", static_cast<uint32_t>(object));
            break;
        case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV:
            dump_enum<Format>(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAntiLagModeAMD(const VkAntiLagModeAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD:
            dump_enum<Format>(settings, "VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD", static_cast<uint32_t>(object));
            break;
        case VK_ANTI_LAG_MODE_ON_AMD:
            dump_enum<Format>(settings, "VK_ANTI_LAG_MODE_ON_AMD", static_cast<uint32_t>(object));
            break;
        case VK_ANTI_LAG_MODE_OFF_AMD:
            dump_enum<Format>(settings, "VK_ANTI_LAG_MODE_OFF_AMD", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAntiLagStageAMD(const VkAntiLagStageAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_ANTI_LAG_STAGE_INPUT_AMD:
            dump_enum<Format>(settings, "VK_ANTI_LAG_STAGE_INPUT_AMD", static_cast<uint32_t>(object));
            break;
        case VK_ANTI_LAG_STAGE_PRESENT_AMD:
            dump_enum<Format>(settings, "VK_ANTI_LAG_STAGE_PRESENT_AMD", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
template <ApiDumpFormat Format>
void dump_VkCompressedTriangleFormatAMDX(const VkCompressedTriangleFormatAMDX object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX:
            dump_enum<Format>(settings, "VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_ENABLE_BETA_EXTENSIONS
template <ApiDumpFormat Format>
void dump_VkShaderCodeTypeEXT(const VkShaderCodeTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SHADER_CODE_TYPE_BINARY_EXT:
            dump_enum<Format>(settings, "VK_SHADER_CODE_TYPE_BINARY_EXT", static_cast<uint32_t>(object));
            break;
        case VK_SHADER_CODE_TYPE_SPIRV_EXT:
            dump_enum<Format>(settings, "VK_SHADER_CODE_TYPE_SPIRV_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDepthClampModeEXT(const VkDepthClampModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT:
            dump_enum<Format>(settings, "VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT:
            dump_enum<Format>(settings, "VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkRayTracingInvocationReorderModeEXT(const VkRayTracingInvocationReorderModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT:
            dump_enum<Format>(settings, "VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT", static_cast<uint32_t>(object));
            break;
        case VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT:
            dump_enum<Format>(settings, "VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkCooperativeVectorMatrixLayoutNV(const VkCooperativeVectorMatrixLayoutNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV:
            dump_enum<Format>(settings, "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV", static_cast<uint32_t>(object));
            break;
        case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV:
            dump_enum<Format>(settings, "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV", static_cast<uint32_t>(object));
            break;
        case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV:
            dump_enum<Format>(settings, "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV", static_cast<uint32_t>(object));
            break;
        case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV:
            dump_enum<Format>(settings, "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkLayerSettingTypeEXT(const VkLayerSettingTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_LAYER_SETTING_TYPE_BOOL32_EXT:
            dump_enum<Format>(settings, "VK_LAYER_SETTING_TYPE_BOOL32_EXT", static_cast<uint32_t>(object));
            break;
        case VK_LAYER_SETTING_TYPE_INT32_EXT:
            dump_enum<Format>(settings, "VK_LAYER_SETTING_TYPE_INT32_EXT", static_cast<uint32_t>(object));
            break;
        case VK_LAYER_SETTING_TYPE_INT64_EXT:
            dump_enum<Format>(settings, "VK_LAYER_SETTING_TYPE_INT64_EXT", static_cast<uint32_t>(object));
            break;
        case VK_LAYER_SETTING_TYPE_UINT32_EXT:
            dump_enum<Format>(settings, "VK_LAYER_SETTING_TYPE_UINT32_EXT", static_cast<uint32_t>(object));
            break;
        case VK_LAYER_SETTING_TYPE_UINT64_EXT:
            dump_enum<Format>(settings, "VK_LAYER_SETTING_TYPE_UINT64_EXT", static_cast<uint32_t>(object));
            break;
        case VK_LAYER_SETTING_TYPE_FLOAT32_EXT:
            dump_enum<Format>(settings, "VK_LAYER_SETTING_TYPE_FLOAT32_EXT", static_cast<uint32_t>(object));
            break;
        case VK_LAYER_SETTING_TYPE_FLOAT64_EXT:
            dump_enum<Format>(settings, "VK_LAYER_SETTING_TYPE_FLOAT64_EXT", static_cast<uint32_t>(object));
            break;
        case VK_LAYER_SETTING_TYPE_STRING_EXT:
            dump_enum<Format>(settings, "VK_LAYER_SETTING_TYPE_STRING_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkLatencyMarkerNV(const VkLatencyMarkerNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_LATENCY_MARKER_SIMULATION_START_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_SIMULATION_START_NV", static_cast<uint32_t>(object));
            break;
        case VK_LATENCY_MARKER_SIMULATION_END_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_SIMULATION_END_NV", static_cast<uint32_t>(object));
            break;
        case VK_LATENCY_MARKER_RENDERSUBMIT_START_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_RENDERSUBMIT_START_NV", static_cast<uint32_t>(object));
            break;
        case VK_LATENCY_MARKER_RENDERSUBMIT_END_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_RENDERSUBMIT_END_NV", static_cast<uint32_t>(object));
            break;
        case VK_LATENCY_MARKER_PRESENT_START_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_PRESENT_START_NV", static_cast<uint32_t>(object));
            break;
        case VK_LATENCY_MARKER_PRESENT_END_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_PRESENT_END_NV", static_cast<uint32_t>(object));
            break;
        case VK_LATENCY_MARKER_INPUT_SAMPLE_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_INPUT_SAMPLE_NV", static_cast<uint32_t>(object));
            break;
        case VK_LATENCY_MARKER_TRIGGER_FLASH_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_TRIGGER_FLASH_NV", static_cast<uint32_t>(object));
            break;
        case VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV", static_cast<uint32_t>(object));
            break;
        case VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV", static_cast<uint32_t>(object));
            break;
        case VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV", static_cast<uint32_t>(object));
            break;
        case VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV:
            dump_enum<Format>(settings, "VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkOutOfBandQueueTypeNV(const VkOutOfBandQueueTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV:
            dump_enum<Format>(settings, "VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV", static_cast<uint32_t>(object));
            break;
        case VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV:
            dump_enum<Format>(settings, "VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSessionBindPointARM(const VkDataGraphPipelineSessionBindPointARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_OPTICAL_FLOW_CACHE_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_OPTICAL_FLOW_CACHE_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_NEURAL_ACCELERATOR_STATISTICS_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_NEURAL_ACCELERATOR_STATISTICS_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSessionBindPointTypeARM(const VkDataGraphPipelineSessionBindPointTypeARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelinePropertyARM(const VkDataGraphPipelinePropertyARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_PIPELINE_PROPERTY_NEURAL_ACCELERATOR_DEBUG_DATABASE_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_PROPERTY_NEURAL_ACCELERATOR_DEBUG_DATABASE_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_PIPELINE_PROPERTY_NEURAL_ACCELERATOR_STATISTICS_INFO_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_PROPERTY_NEURAL_ACCELERATOR_STATISTICS_INFO_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDataGraphProcessingEngineTypeARM(const VkPhysicalDeviceDataGraphProcessingEngineTypeARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDataGraphOperationTypeARM(const VkPhysicalDeviceDataGraphOperationTypeARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_OPTICAL_FLOW_ARM:
            dump_enum<Format>(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_OPTICAL_FLOW_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphTOSALevelARM(const VkDataGraphTOSALevelARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DATA_GRAPH_TOSA_LEVEL_NONE_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_TOSA_LEVEL_NONE_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_TOSA_LEVEL_8K_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_TOSA_LEVEL_8K_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkBlockMatchWindowCompareModeQCOM(const VkBlockMatchWindowCompareModeQCOM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM:
            dump_enum<Format>(settings, "VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM:
            dump_enum<Format>(settings, "VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkCubicFilterWeightsQCOM(const VkCubicFilterWeightsQCOM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM:
            dump_enum<Format>(settings, "VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM:
            dump_enum<Format>(settings, "VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM:
            dump_enum<Format>(settings, "VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM", static_cast<uint32_t>(object));
            break;
        case VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM:
            dump_enum<Format>(settings, "VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkLayeredDriverUnderlyingApiMSFT(const VkLayeredDriverUnderlyingApiMSFT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT:
            dump_enum<Format>(settings, "VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT", static_cast<uint32_t>(object));
            break;
        case VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT:
            dump_enum<Format>(settings, "VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplaySurfaceStereoTypeNV(const VkDisplaySurfaceStereoTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV:
            dump_enum<Format>(settings, "VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV", static_cast<uint32_t>(object));
            break;
        case VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV:
            dump_enum<Format>(settings, "VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV", static_cast<uint32_t>(object));
            break;
        case VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV:
            dump_enum<Format>(settings, "VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV", static_cast<uint32_t>(object));
            break;
        case VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV:
            dump_enum<Format>(settings, "VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureTypeNV(const VkClusterAccelerationStructureTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV", static_cast<uint32_t>(object));
            break;
        case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureOpTypeNV(const VkClusterAccelerationStructureOpTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV", static_cast<uint32_t>(object));
            break;
        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV", static_cast<uint32_t>(object));
            break;
        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV", static_cast<uint32_t>(object));
            break;
        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV", static_cast<uint32_t>(object));
            break;
        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV", static_cast<uint32_t>(object));
            break;
        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureOpModeNV(const VkClusterAccelerationStructureOpModeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV", static_cast<uint32_t>(object));
            break;
        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV", static_cast<uint32_t>(object));
            break;
        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV:
            dump_enum<Format>(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPartitionedAccelerationStructureOpTypeNV(const VkPartitionedAccelerationStructureOpTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV:
            dump_enum<Format>(settings, "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV", static_cast<uint32_t>(object));
            break;
        case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV:
            dump_enum<Format>(settings, "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV", static_cast<uint32_t>(object));
            break;
        case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV:
            dump_enum<Format>(settings, "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectExecutionSetInfoTypeEXT(const VkIndirectExecutionSetInfoTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsTokenTypeEXT(const VkIndirectCommandsTokenTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT", static_cast<uint32_t>(object));
            break;
        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT:
            dump_enum<Format>(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphModelCacheTypeQCOM(const VkDataGraphModelCacheTypeQCOM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphOpticalFlowPerformanceLevelARM(const VkDataGraphOpticalFlowPerformanceLevelARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineNodeTypeARM(const VkDataGraphPipelineNodeTypeARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DATA_GRAPH_PIPELINE_NODE_TYPE_OPTICAL_FLOW_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_NODE_TYPE_OPTICAL_FLOW_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineNodeConnectionTypeARM(const VkDataGraphPipelineNodeConnectionTypeARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_INPUT_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_INPUT_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_REFERENCE_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_REFERENCE_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_HINT_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_HINT_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_FLOW_VECTOR_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_FLOW_VECTOR_ARM", static_cast<uint32_t>(object));
            break;
        case VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_COST_ARM:
            dump_enum<Format>(settings, "VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_COST_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkThrottleHintTypeSEC(const VkThrottleHintTypeSEC object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_THROTTLE_HINT_TYPE_DEFAULT_SEC:
            dump_enum<Format>(settings, "VK_THROTTLE_HINT_TYPE_DEFAULT_SEC", static_cast<uint32_t>(object));
            break;
        case VK_THROTTLE_HINT_TYPE_LOW_SEC:
            dump_enum<Format>(settings, "VK_THROTTLE_HINT_TYPE_LOW_SEC", static_cast<uint32_t>(object));
            break;
        case VK_THROTTLE_HINT_TYPE_HIGH_SEC:
            dump_enum<Format>(settings, "VK_THROTTLE_HINT_TYPE_HIGH_SEC", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkNeuralAcceleratorStatisticsModeARM(const VkNeuralAcceleratorStatisticsModeARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_NEURAL_ACCELERATOR_STATISTICS_MODE_DISABLED_ARM:
            dump_enum<Format>(settings, "VK_NEURAL_ACCELERATOR_STATISTICS_MODE_DISABLED_ARM", static_cast<uint32_t>(object));
            break;
        case VK_NEURAL_ACCELERATOR_STATISTICS_MODE_STATISTICS0_ARM:
            dump_enum<Format>(settings, "VK_NEURAL_ACCELERATOR_STATISTICS_MODE_STATISTICS0_ARM", static_cast<uint32_t>(object));
            break;
        case VK_NEURAL_ACCELERATOR_STATISTICS_MODE_STATISTICS1_ARM:
            dump_enum<Format>(settings, "VK_NEURAL_ACCELERATOR_STATISTICS_MODE_STATISTICS1_ARM", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkBuildAccelerationStructureModeKHR(const VkBuildAccelerationStructureModeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR:
            dump_enum<Format>(settings, "VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR", static_cast<uint32_t>(object));
            break;
        case VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR:
            dump_enum<Format>(settings, "VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderGroupShaderKHR(const VkShaderGroupShaderKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    switch ((int64_t)object) {
        case VK_SHADER_GROUP_SHADER_GENERAL_KHR:
            dump_enum<Format>(settings, "VK_SHADER_GROUP_SHADER_GENERAL_KHR", static_cast<uint32_t>(object));
            break;
        case VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR:
            dump_enum<Format>(settings, "VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR", static_cast<uint32_t>(object));
            break;
        case VK_SHADER_GROUP_SHADER_ANY_HIT_KHR:
            dump_enum<Format>(settings, "VK_SHADER_GROUP_SHADER_ANY_HIT_KHR", static_cast<uint32_t>(object));
            break;
        case VK_SHADER_GROUP_SHADER_INTERSECTION_KHR:
            dump_enum<Format>(settings, "VK_SHADER_GROUP_SHADER_INTERSECTION_KHR", static_cast<uint32_t>(object));
            break;
        default:
            dump_enum_with_value<Format>(settings, "UNKNOWN", static_cast<uint32_t>(object));
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

//========================= Bitmask Implementations =========================//

template <ApiDumpFormat Format>
void dump_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_BLIT_SRC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_BLIT_SRC_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_BLIT_DST_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_BLIT_DST_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_TRANSFER_DST_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_DISJOINT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_DISJOINT_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkImageCreateFlagBits(const VkImageCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPARSE_BINDING_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_SPARSE_ALIASED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_ALIAS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_ALIAS_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_PROTECTED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_PROTECTED_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_DISJOINT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_DISJOINT_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSampleCountFlagBits(const VkSampleCountFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SAMPLE_COUNT_1_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_1_BIT";
        is_first = false;
    }
    if (object & VK_SAMPLE_COUNT_2_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_2_BIT";
        is_first = false;
    }
    if (object & VK_SAMPLE_COUNT_4_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_4_BIT";
        is_first = false;
    }
    if (object & VK_SAMPLE_COUNT_8_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_8_BIT";
        is_first = false;
    }
    if (object & VK_SAMPLE_COUNT_16_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_16_BIT";
        is_first = false;
    }
    if (object & VK_SAMPLE_COUNT_32_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_32_BIT";
        is_first = false;
    }
    if (object & VK_SAMPLE_COUNT_64_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_64_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkImageUsageFlagBits(const VkImageUsageFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TRANSFER_SRC_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_TRANSFER_DST_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TRANSFER_DST_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_SAMPLED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_SAMPLED_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_STORAGE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_STORAGE_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_HOST_TRANSFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_HOST_TRANSFER_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkInstanceCreateFlagBits(const VkInstanceCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT";
        is_first = false;
    }
    if (object & VK_MEMORY_HEAP_MULTI_INSTANCE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT";
        is_first = false;
    }
    if (object & VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT";
        is_first = false;
    }
    if (object & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT";
        is_first = false;
    }
    if (object & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT";
        is_first = false;
    }
    if (object & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_HOST_CACHED_BIT";
        is_first = false;
    }
    if (object & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT";
        is_first = false;
    }
    if (object & VK_MEMORY_PROPERTY_PROTECTED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_PROTECTED_BIT";
        is_first = false;
    }
    if (object & VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD";
        is_first = false;
    }
    if (object & VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD";
        is_first = false;
    }
    if (object & VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkQueueFlagBits(const VkQueueFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_QUEUE_GRAPHICS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_GRAPHICS_BIT";
        is_first = false;
    }
    if (object & VK_QUEUE_COMPUTE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_COMPUTE_BIT";
        is_first = false;
    }
    if (object & VK_QUEUE_TRANSFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_TRANSFER_BIT";
        is_first = false;
    }
    if (object & VK_QUEUE_SPARSE_BINDING_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_SPARSE_BINDING_BIT";
        is_first = false;
    }
    if (object & VK_QUEUE_PROTECTED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_PROTECTED_BIT";
        is_first = false;
    }
    if (object & VK_QUEUE_VIDEO_DECODE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_VIDEO_DECODE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_QUEUE_VIDEO_ENCODE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_VIDEO_ENCODE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_QUEUE_OPTICAL_FLOW_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_OPTICAL_FLOW_BIT_NV";
        is_first = false;
    }
    if (object & VK_QUEUE_DATA_GRAPH_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_DATA_GRAPH_BIT_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkShaderStageFlagBits(const VkShaderStageFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SHADER_STAGE_VERTEX_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_VERTEX_BIT";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_GEOMETRY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_GEOMETRY_BIT";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_FRAGMENT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_FRAGMENT_BIT";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_COMPUTE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_COMPUTE_BIT";
        is_first = false;
    }
    if (object == VK_SHADER_STAGE_ALL_GRAPHICS) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_ALL_GRAPHICS";
        is_first = false;
    }
    if (object == VK_SHADER_STAGE_ALL) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_ALL";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_RAYGEN_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_RAYGEN_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_ANY_HIT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_ANY_HIT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_MISS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_MISS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_INTERSECTION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_INTERSECTION_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_CALLABLE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_CALLABLE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_TASK_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_TASK_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_MESH_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_MESH_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI";
        is_first = false;
    }
    if (object & VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT";
        is_first = false;
    }
    if (object & VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPipelineStageFlagBits(const VkPipelineStageFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_VERTEX_INPUT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_VERTEX_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_TRANSFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TRANSFER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_HOST_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_HOST_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT";
        is_first = false;
    }
    if (object == VK_PIPELINE_STAGE_NONE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_NONE";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkMemoryMapFlagBits(const VkMemoryMapFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_MEMORY_MAP_PLACED_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_MAP_PLACED_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkImageAspectFlagBits(const VkImageAspectFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_IMAGE_ASPECT_COLOR_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_COLOR_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_ASPECT_DEPTH_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_DEPTH_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_ASPECT_STENCIL_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_STENCIL_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_ASPECT_METADATA_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_METADATA_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_ASPECT_PLANE_0_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_PLANE_0_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_ASPECT_PLANE_1_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_PLANE_1_BIT";
        is_first = false;
    }
    if (object & VK_IMAGE_ASPECT_PLANE_2_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_PLANE_2_BIT";
        is_first = false;
    }
    if (object == VK_IMAGE_ASPECT_NONE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_NONE";
        is_first = false;
    }
    if (object & VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSparseImageFormatFlagBits(const VkSparseImageFormatFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT";
        is_first = false;
    }
    if (object & VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT";
        is_first = false;
    }
    if (object & VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSparseMemoryBindFlagBits(const VkSparseMemoryBindFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SPARSE_MEMORY_BIND_METADATA_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_MEMORY_BIND_METADATA_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkFenceCreateFlagBits(const VkFenceCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_FENCE_CREATE_SIGNALED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FENCE_CREATE_SIGNALED_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkQueryPoolCreateFlagBits(const VkQueryPoolCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_QUERY_POOL_CREATE_RESET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_POOL_CREATE_RESET_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkQueryResultFlagBits(const VkQueryResultFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_QUERY_RESULT_64_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_64_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_RESULT_WAIT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_WAIT_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_RESULT_PARTIAL_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_PARTIAL_BIT";
        is_first = false;
    }
    if (object & VK_QUERY_RESULT_WITH_STATUS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_WITH_STATUS_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkBufferCreateFlagBits(const VkBufferCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_SPARSE_BINDING_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_CREATE_SPARSE_ALIASED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_CREATE_PROTECTED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_PROTECTED_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkBufferUsageFlagBits(const VkBufferUsageFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_BUFFER_USAGE_TRANSFER_SRC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFER_SRC_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_TRANSFER_DST_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFER_DST_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_INDEX_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_INDEX_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkAccessFlagBits(const VkAccessFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_ACCESS_INDIRECT_COMMAND_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_INDIRECT_COMMAND_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_INDEX_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_INDEX_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_UNIFORM_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_UNIFORM_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_INPUT_ATTACHMENT_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_SHADER_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_SHADER_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_SHADER_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_SHADER_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_COLOR_ATTACHMENT_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_TRANSFER_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFER_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_TRANSFER_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFER_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_HOST_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_HOST_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_HOST_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_HOST_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_MEMORY_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_MEMORY_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_MEMORY_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_MEMORY_WRITE_BIT";
        is_first = false;
    }
    if (object == VK_ACCESS_NONE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_NONE";
        is_first = false;
    }
    if (object & VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDependencyFlagBits(const VkDependencyFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DEPENDENCY_BY_REGION_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_BY_REGION_BIT";
        is_first = false;
    }
    if (object & VK_DEPENDENCY_DEVICE_GROUP_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_DEVICE_GROUP_BIT";
        is_first = false;
    }
    if (object & VK_DEPENDENCY_VIEW_LOCAL_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_VIEW_LOCAL_BIT";
        is_first = false;
    }
    if (object & VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR";
        is_first = false;
    }
    if (object & VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_COMMAND_POOL_CREATE_TRANSIENT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT";
        is_first = false;
    }
    if (object & VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_COMMAND_POOL_CREATE_PROTECTED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_CREATE_PROTECTED_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkQueryControlFlagBits(const VkQueryControlFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_QUERY_CONTROL_PRECISE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_CONTROL_PRECISE_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT";
        is_first = false;
    }
    if (object & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT";
        is_first = false;
    }
    if (object & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkEventCreateFlagBits(const VkEventCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_EVENT_CREATE_DEVICE_ONLY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EVENT_CREATE_DEVICE_ONLY_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_DERIVATIVE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DERIVATIVE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_DISPATCH_BASE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DISPATCH_BASE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_LIBRARY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_LIBRARY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPipelineLayoutCreateFlagBits(const VkPipelineLayoutCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_LAYOUT_CREATE_NO_TASK_SHADER_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_LAYOUT_CREATE_NO_TASK_SHADER_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkColorComponentFlagBits(const VkColorComponentFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_COLOR_COMPONENT_R_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_R_BIT";
        is_first = false;
    }
    if (object & VK_COLOR_COMPONENT_G_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_G_BIT";
        is_first = false;
    }
    if (object & VK_COLOR_COMPONENT_B_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_B_BIT";
        is_first = false;
    }
    if (object & VK_COLOR_COMPONENT_A_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_A_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkCullModeFlagBits(const VkCullModeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_CULL_MODE_NONE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_NONE";
        is_first = false;
    }
    if (object & VK_CULL_MODE_FRONT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_FRONT_BIT";
        is_first = false;
    }
    if (object & VK_CULL_MODE_BACK_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_BACK_BIT";
        is_first = false;
    }
    if (object == VK_CULL_MODE_FRONT_AND_BACK) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_FRONT_AND_BACK";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPipelineColorBlendStateCreateFlagBits(const VkPipelineColorBlendStateCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPipelineDepthStencilStateCreateFlagBits(const VkPipelineDepthStencilStateCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT";
        is_first = false;
    }
    if (object & VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX";
        is_first = false;
    }
    if (object & VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX";
        is_first = false;
    }
    if (object & VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkStencilFaceFlagBits(const VkStencilFaceFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_STENCIL_FACE_FRONT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_STENCIL_FACE_FRONT_BIT";
        is_first = false;
    }
    if (object & VK_STENCIL_FACE_BACK_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_STENCIL_FACE_BACK_BIT";
        is_first = false;
    }
    if (object == VK_STENCIL_FACE_FRONT_AND_BACK) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_STENCIL_FACE_FRONT_AND_BACK";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SUBGROUP_FEATURE_BASIC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_BASIC_BIT";
        is_first = false;
    }
    if (object & VK_SUBGROUP_FEATURE_VOTE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_VOTE_BIT";
        is_first = false;
    }
    if (object & VK_SUBGROUP_FEATURE_ARITHMETIC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT";
        is_first = false;
    }
    if (object & VK_SUBGROUP_FEATURE_BALLOT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_BALLOT_BIT";
        is_first = false;
    }
    if (object & VK_SUBGROUP_FEATURE_SHUFFLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_SHUFFLE_BIT";
        is_first = false;
    }
    if (object & VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT";
        is_first = false;
    }
    if (object & VK_SUBGROUP_FEATURE_CLUSTERED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_CLUSTERED_BIT";
        is_first = false;
    }
    if (object & VK_SUBGROUP_FEATURE_QUAD_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_QUAD_BIT";
        is_first = false;
    }
    if (object & VK_SUBGROUP_FEATURE_ROTATE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_ROTATE_BIT";
        is_first = false;
    }
    if (object & VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT";
        is_first = false;
    }
    if (object & VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT";
        is_first = false;
    }
    if (object & VK_PEER_MEMORY_FEATURE_COPY_DST_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT";
        is_first = false;
    }
    if (object & VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT";
        is_first = false;
    }
    if (object & VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT";
        is_first = false;
    }
    if (object & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT";
        is_first = false;
    }
    if (object & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT";
        is_first = false;
    }
    if (object & VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkFenceImportFlagBits(const VkFenceImportFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_FENCE_IMPORT_TEMPORARY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FENCE_IMPORT_TEMPORARY_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT";
        is_first = false;
    }
    if (object & VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkResolveModeFlagBits(const VkResolveModeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_RESOLVE_MODE_NONE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_NONE";
        is_first = false;
    }
    if (object & VK_RESOLVE_MODE_SAMPLE_ZERO_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT";
        is_first = false;
    }
    if (object & VK_RESOLVE_MODE_AVERAGE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_AVERAGE_BIT";
        is_first = false;
    }
    if (object & VK_RESOLVE_MODE_MIN_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_MIN_BIT";
        is_first = false;
    }
    if (object & VK_RESOLVE_MODE_MAX_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_MAX_BIT";
        is_first = false;
    }
    if (object & VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID";
        is_first = false;
    }
    if (object & VK_RESOLVE_MODE_CUSTOM_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_CUSTOM_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SEMAPHORE_WAIT_ANY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SEMAPHORE_WAIT_ANY_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT";
        is_first = false;
    }
    if (object & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkToolPurposeFlagBits(const VkToolPurposeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_TOOL_PURPOSE_VALIDATION_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_VALIDATION_BIT";
        is_first = false;
    }
    if (object & VK_TOOL_PURPOSE_PROFILING_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_PROFILING_BIT";
        is_first = false;
    }
    if (object & VK_TOOL_PURPOSE_TRACING_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_TRACING_BIT";
        is_first = false;
    }
    if (object & VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT";
        is_first = false;
    }
    if (object & VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT";
        is_first = false;
    }
    if (object & VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPipelineStageFlagBits2(const VkPipelineStageFlagBits2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_PIPELINE_STAGE_2_NONE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_NONE";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_HOST_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_HOST_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_COPY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COPY_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_RESOLVE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_RESOLVE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_BLIT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_BLIT_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_CLEAR_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CLEAR_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkAccessFlagBits2(const VkAccessFlagBits2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_ACCESS_2_NONE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_NONE";
        is_first = false;
    }
    if (object & VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_INDEX_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INDEX_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_UNIFORM_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_UNIFORM_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_SHADER_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_SHADER_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_TRANSFER_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFER_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_TRANSFER_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFER_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_HOST_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_HOST_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_HOST_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_HOST_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_MEMORY_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MEMORY_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_MEMORY_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MEMORY_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_SHADER_SAMPLED_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_SHADER_STORAGE_READ_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_STORAGE_READ_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI";
        is_first = false;
    }
    if (object & VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCESS_2_MICROMAP_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MICROMAP_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV";
        is_first = false;
    }
    if (object & VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV";
        is_first = false;
    }
    if (object & VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM";
        is_first = false;
    }
    if (object & VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM";
        is_first = false;
    }
    if (object & VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSubmitFlagBits(const VkSubmitFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SUBMIT_PROTECTED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBMIT_PROTECTED_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkFormatFeatureFlagBits2(const VkFormatFeatureFlagBits2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_BLIT_SRC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_BLIT_DST_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BLIT_DST_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_DISJOINT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DISJOINT_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_BLOCK_MATCHING_SXD_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BLOCK_MATCHING_SXD_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_2D_BIT_IMG) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_2D_BIT_IMG";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_IMAGE_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_IMAGE_BIT_ARM";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_VECTOR_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_VECTOR_BIT_ARM";
        is_first = false;
    }
    if (object & VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_COST_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_COST_BIT_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPipelineCreationFeedbackFlagBits(const VkPipelineCreationFeedbackFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkRenderingFlagBits(const VkRenderingFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT";
        is_first = false;
    }
    if (object & VK_RENDERING_SUSPENDING_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_SUSPENDING_BIT";
        is_first = false;
    }
    if (object & VK_RENDERING_RESUMING_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_RESUMING_BIT";
        is_first = false;
    }
    if (object & VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_RENDERING_CONTENTS_INLINE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_CONTENTS_INLINE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE";
        is_first = false;
    }
    if (object & VK_RENDERING_FRAGMENT_REGION_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_FRAGMENT_REGION_BIT_EXT";
        is_first = false;
    }
    if (object & VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkMemoryUnmapFlagBits(const VkMemoryUnmapFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_MEMORY_UNMAP_RESERVE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_UNMAP_RESERVE_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkBufferUsageFlagBits2(const VkBufferUsageFlagBits2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_TRANSFER_DST_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFER_DST_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkHostImageCopyFlagBits(const VkHostImageCopyFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_HOST_IMAGE_COPY_MEMCPY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_HOST_IMAGE_COPY_MEMCPY_BIT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPipelineCreateFlagBits2(const VkPipelineCreateFlagBits2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_DERIVATIVE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_INSTRUMENT_SHADERS_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_INSTRUMENT_SHADERS_BIT_ARM";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSurfaceTransformFlagBitsKHR(const VkSurfaceTransformFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkCompositeAlphaFlagBitsKHR(const VkCompositeAlphaFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSwapchainCreateFlagBitsKHR(const VkSwapchainCreateFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR";
        is_first = false;
    }
    if (object & VK_SWAPCHAIN_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDeviceGroupPresentModeFlagBitsKHR(const VkDeviceGroupPresentModeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR";
        is_first = false;
    }
    if (object & VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR";
        is_first = false;
    }
    if (object & VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDisplayPlaneAlphaFlagBitsKHR(const VkDisplayPlaneAlphaFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR";
        is_first = false;
    }
    if (object & VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR";
        is_first = false;
    }
    if (object & VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoCodecOperationFlagBitsKHR(const VkVideoCodecOperationFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_VIDEO_CODEC_OPERATION_NONE_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_NONE_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoChromaSubsamplingFlagBitsKHR(const VkVideoChromaSubsamplingFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoComponentBitDepthFlagBitsKHR(const VkVideoComponentBitDepthFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoCapabilityFlagBitsKHR(const VkVideoCapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoSessionCreateFlagBitsKHR(const VkVideoSessionCreateFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoSessionParametersCreateFlagBitsKHR(const VkVideoSessionParametersCreateFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoCodingControlFlagBitsKHR(const VkVideoCodingControlFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoDecodeCapabilityFlagBitsKHR(const VkVideoDecodeCapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoDecodeUsageFlagBitsKHR(const VkVideoDecodeUsageFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_VIDEO_DECODE_USAGE_DEFAULT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_DEFAULT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264CapabilityFlagBitsKHR(const VkVideoEncodeH264CapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264StdFlagBitsKHR(const VkVideoEncodeH264StdFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264RateControlFlagBitsKHR(const VkVideoEncodeH264RateControlFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265CapabilityFlagBitsKHR(const VkVideoEncodeH265CapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265StdFlagBitsKHR(const VkVideoEncodeH265StdFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265CtbSizeFlagBitsKHR(const VkVideoEncodeH265CtbSizeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265TransformBlockSizeFlagBitsKHR(const VkVideoEncodeH265TransformBlockSizeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265RateControlFlagBitsKHR(const VkVideoEncodeH265RateControlFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoDecodeH264PictureLayoutFlagBitsKHR(const VkVideoDecodeH264PictureLayoutFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPerformanceCounterDescriptionFlagBitsKHR(const VkPerformanceCounterDescriptionFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkAcquireProfilingLockFlagBitsKHR(const VkAcquireProfilingLockFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeFlagBitsKHR(const VkVideoEncodeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeCapabilityFlagBitsKHR(const VkVideoEncodeCapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeRateControlModeFlagBitsKHR(const VkVideoEncodeRateControlModeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeFeedbackFlagBitsKHR(const VkVideoEncodeFeedbackFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_FEEDBACK_AVERAGE_QUANTIZATION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_AVERAGE_QUANTIZATION_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_FEEDBACK_MIN_QUANTIZATION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_MIN_QUANTIZATION_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_FEEDBACK_MAX_QUANTIZATION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_MAX_QUANTIZATION_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_FEEDBACK_INTRA_PIXELS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_INTRA_PIXELS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_FEEDBACK_INTER_PIXELS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_INTER_PIXELS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_FEEDBACK_SKIPPED_PIXELS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_SKIPPED_PIXELS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_FEEDBACK_PICTURE_PARTITION_COUNT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_PICTURE_PARTITION_COUNT_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeUsageFlagBitsKHR(const VkVideoEncodeUsageFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeContentFlagBitsKHR(const VkVideoEncodeContentFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkAddressCommandFlagBitsKHR(const VkAddressCommandFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_ADDRESS_COMMAND_PROTECTED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COMMAND_PROTECTED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ADDRESS_COMMAND_FULLY_BOUND_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COMMAND_FULLY_BOUND_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ADDRESS_COMMAND_STORAGE_BUFFER_USAGE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COMMAND_STORAGE_BUFFER_USAGE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ADDRESS_COMMAND_UNKNOWN_STORAGE_BUFFER_USAGE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COMMAND_UNKNOWN_STORAGE_BUFFER_USAGE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ADDRESS_COMMAND_TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COMMAND_TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ADDRESS_COMMAND_UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COMMAND_UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkConditionalRenderingFlagBitsEXT(const VkConditionalRenderingFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkAccelerationStructureCreateFlagBitsKHR(const VkAccelerationStructureCreateFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT";
        is_first = false;
    }
    if (object & VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPresentScalingFlagBitsKHR(const VkPresentScalingFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PRESENT_SCALING_STRETCH_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_SCALING_STRETCH_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPresentGravityFlagBitsKHR(const VkPresentGravityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PRESENT_GRAVITY_MIN_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_GRAVITY_MIN_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PRESENT_GRAVITY_MAX_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_GRAVITY_MAX_BIT_KHR";
        is_first = false;
    }
    if (object & VK_PRESENT_GRAVITY_CENTERED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_GRAVITY_CENTERED_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1CapabilityFlagBitsKHR(const VkVideoEncodeAV1CapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1StdFlagBitsKHR(const VkVideoEncodeAV1StdFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(const VkVideoEncodeAV1SuperblockSizeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1RateControlFlagBitsKHR(const VkVideoEncodeAV1RateControlFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkAddressCopyFlagBitsKHR(const VkAddressCopyFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ADDRESS_COPY_SPARSE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COPY_SPARSE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_ADDRESS_COPY_PROTECTED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COPY_PROTECTED_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeIntraRefreshModeFlagBitsKHR(const VkVideoEncodeIntraRefreshModeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDeviceFaultFlagBitsKHR(const VkDeviceFaultFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DEVICE_FAULT_FLAG_DEVICE_LOST_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_FAULT_FLAG_DEVICE_LOST_KHR";
        is_first = false;
    }
    if (object & VK_DEVICE_FAULT_FLAG_MEMORY_ADDRESS_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_FAULT_FLAG_MEMORY_ADDRESS_KHR";
        is_first = false;
    }
    if (object & VK_DEVICE_FAULT_FLAG_INSTRUCTION_ADDRESS_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_FAULT_FLAG_INSTRUCTION_ADDRESS_KHR";
        is_first = false;
    }
    if (object & VK_DEVICE_FAULT_FLAG_VENDOR_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_FAULT_FLAG_VENDOR_KHR";
        is_first = false;
    }
    if (object & VK_DEVICE_FAULT_FLAG_WATCHDOG_TIMEOUT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_FAULT_FLAG_WATCHDOG_TIMEOUT_KHR";
        is_first = false;
    }
    if (object & VK_DEVICE_FAULT_FLAG_OVERFLOW_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_FAULT_FLAG_OVERFLOW_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkAccessFlagBits3KHR(const VkAccessFlagBits3KHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_ACCESS_3_NONE_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_3_NONE_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodePerPartitionFeedbackFlagBitsKHR(const VkVideoEncodePerPartitionFeedbackFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_STATUS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_STATUS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkRenderingAttachmentFlagBitsKHR(const VkRenderingAttachmentFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR";
        is_first = false;
    }
    if (object & VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR";
        is_first = false;
    }
    if (object & VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkResolveImageFlagBitsKHR(const VkResolveImageFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR";
        is_first = false;
    }
    if (object & VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkFormatFeatureFlagBits4KHR(const VkFormatFeatureFlagBits4KHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkImageUsageFlagBits2KHR(const VkImageUsageFlagBits2KHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_IMAGE_USAGE_2_TRANSFER_SRC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_TRANSFER_SRC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_TRANSFER_DST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_TRANSFER_DST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_SAMPLED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_SAMPLED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_STORAGE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_STORAGE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_COLOR_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_COLOR_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_TRANSIENT_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_TRANSIENT_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_INPUT_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_INPUT_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_FRAGMENT_DENSITY_MAP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_FRAGMENT_DENSITY_MAP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_VIDEO_DECODE_DST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_VIDEO_DECODE_DST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_VIDEO_DECODE_DPB_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_VIDEO_DECODE_DPB_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_VIDEO_ENCODE_DPB_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_VIDEO_ENCODE_DPB_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_INVOCATION_MASK_BIT_HUAWEI) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_INVOCATION_MASK_BIT_HUAWEI";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_SAMPLE_WEIGHT_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_SAMPLE_WEIGHT_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_SAMPLE_BLOCK_MATCH_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_SAMPLE_BLOCK_MATCH_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_HOST_TRANSFER_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_HOST_TRANSFER_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_TENSOR_ALIASING_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_TENSOR_ALIASING_BIT_ARM";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_USAGE_2_TILE_MEMORY_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_2_TILE_MEMORY_BIT_QCOM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkImageCreateFlagBits2KHR(const VkImageCreateFlagBits2KHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_IMAGE_CREATE_2_SPARSE_BINDING_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_SPARSE_BINDING_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_SPARSE_RESIDENCY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_SPARSE_RESIDENCY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_SPARSE_ALIASED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_SPARSE_ALIASED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_MUTABLE_FORMAT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_MUTABLE_FORMAT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_CUBE_COMPATIBLE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_CUBE_COMPATIBLE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_2D_ARRAY_COMPATIBLE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_2D_ARRAY_COMPATIBLE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_EXTENDED_USAGE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_EXTENDED_USAGE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_DISJOINT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_DISJOINT_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_ALIAS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_ALIAS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_PROTECTED_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_PROTECTED_BIT_KHR";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_CORNER_SAMPLED_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_CORNER_SAMPLED_BIT_NV";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_SUBSAMPLED_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_SUBSAMPLED_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_2D_VIEW_COMPATIBLE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_2D_VIEW_COMPATIBLE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_CREATE_2_VIDEO_PROFILE_INDEPENDENT_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2_VIDEO_PROFILE_INDEPENDENT_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDebugReportFlagBitsEXT(const VkDebugReportFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_INFORMATION_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_WARNING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_ERROR_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DEBUG_REPORT_DEBUG_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_DEBUG_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkExternalMemoryHandleTypeFlagBitsNV(const VkExternalMemoryHandleTypeFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkExternalMemoryFeatureFlagBitsNV(const VkExternalMemoryFeatureFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV";
        is_first = false;
    }
    if (object & VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSurfaceCounterFlagBitsEXT(const VkSurfaceCounterFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SURFACE_COUNTER_VBLANK_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_COUNTER_VBLANK_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDebugUtilsMessageSeverityFlagBitsEXT(const VkDebugUtilsMessageSeverityFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDebugUtilsMessageTypeFlagBitsEXT(const VkDebugUtilsMessageTypeFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkGpaSqShaderStageFlagBitsAMD(const VkGpaSqShaderStageFlagBitsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_GPA_SQ_SHADER_STAGE_PS_BIT_AMD) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GPA_SQ_SHADER_STAGE_PS_BIT_AMD";
        is_first = false;
    }
    if (object & VK_GPA_SQ_SHADER_STAGE_VS_BIT_AMD) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GPA_SQ_SHADER_STAGE_VS_BIT_AMD";
        is_first = false;
    }
    if (object & VK_GPA_SQ_SHADER_STAGE_GS_BIT_AMD) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GPA_SQ_SHADER_STAGE_GS_BIT_AMD";
        is_first = false;
    }
    if (object & VK_GPA_SQ_SHADER_STAGE_ES_BIT_AMD) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GPA_SQ_SHADER_STAGE_ES_BIT_AMD";
        is_first = false;
    }
    if (object & VK_GPA_SQ_SHADER_STAGE_HS_BIT_AMD) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GPA_SQ_SHADER_STAGE_HS_BIT_AMD";
        is_first = false;
    }
    if (object & VK_GPA_SQ_SHADER_STAGE_LS_BIT_AMD) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GPA_SQ_SHADER_STAGE_LS_BIT_AMD";
        is_first = false;
    }
    if (object & VK_GPA_SQ_SHADER_STAGE_CS_BIT_AMD) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GPA_SQ_SHADER_STAGE_CS_BIT_AMD";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkTensorViewCreateFlagBitsARM(const VkTensorViewCreateFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkSpirvResourceTypeFlagBitsEXT(const VkSpirvResourceTypeFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_SPIRV_RESOURCE_TYPE_ALL_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_ALL_EXT";
        is_first = false;
    }
    if (object & VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkGeometryFlagBitsKHR(const VkGeometryFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_GEOMETRY_OPAQUE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_OPAQUE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkGeometryInstanceFlagBitsKHR(const VkGeometryInstanceFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR";
        is_first = false;
    }
    if (object & VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkBuildAccelerationStructureFlagBitsKHR(const VkBuildAccelerationStructureFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR";
        is_first = false;
    }
    if (object & VK_BUILD_ACCELERATION_STRUCTURE_MICROMAP_LOSSY_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_MICROMAP_LOSSY_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPipelineCompilerControlFlagBitsAMD(const VkPipelineCompilerControlFlagBitsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPresentStageFlagBitsEXT(const VkPresentStageFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPastPresentationTimingFlagBitsEXT(const VkPastPresentationTimingFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPresentTimingInfoFlagBitsEXT(const VkPresentTimingInfoFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT";
        is_first = false;
    }
    if (object & VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkShaderCorePropertiesFlagBitsAMD(const VkShaderCorePropertiesFlagBitsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkIndirectStateFlagBitsNV(const VkIndirectStateFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkIndirectCommandsLayoutUsageFlagBitsNV(const VkIndirectCommandsLayoutUsageFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV";
        is_first = false;
    }
    if (object & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV";
        is_first = false;
    }
    if (object & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDeviceDiagnosticsConfigFlagBitsNV(const VkDeviceDiagnosticsConfigFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV";
        is_first = false;
    }
    if (object & VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV";
        is_first = false;
    }
    if (object & VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV";
        is_first = false;
    }
    if (object & VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkTileShadingRenderPassFlagBitsQCOM(const VkTileShadingRenderPassFlagBitsQCOM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM";
        is_first = false;
    }
    if (object & VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#if defined(VK_USE_PLATFORM_METAL_EXT)

template <ApiDumpFormat Format>
void dump_VkExportMetalObjectTypeFlagBitsEXT(const VkExportMetalObjectTypeFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_METAL_EXT

template <ApiDumpFormat Format>
void dump_VkGraphicsPipelineLibraryFlagBitsEXT(const VkGraphicsPipelineLibraryFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkImageCompressionFlagBitsEXT(const VkImageCompressionFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_IMAGE_COMPRESSION_DEFAULT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_DEFAULT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_DISABLED_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_DISABLED_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkImageCompressionFixedRateFlagBitsEXT(const VkImageCompressionFixedRateFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT";
        is_first = false;
    }
    if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDeviceAddressBindingFlagBitsEXT(const VkDeviceAddressBindingFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#if defined(VK_USE_PLATFORM_FUCHSIA)

template <ApiDumpFormat Format>
void dump_VkImageConstraintsInfoFlagBitsFUCHSIA(const VkImageConstraintsInfoFlagBitsFUCHSIA object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA";
        is_first = false;
    }
    if (object & VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA";
        is_first = false;
    }
    if (object & VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA";
        is_first = false;
    }
    if (object & VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA";
        is_first = false;
    }
    if (object & VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_FUCHSIA

template <ApiDumpFormat Format>
void dump_VkFrameBoundaryFlagBitsEXT(const VkFrameBoundaryFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeRgbModelConversionFlagBitsVALVE(const VkVideoEncodeRgbModelConversionFlagBitsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(const VkVideoEncodeRgbRangeCompressionFlagBitsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(const VkVideoEncodeRgbChromaOffsetFlagBitsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE";
        is_first = false;
    }
    if (object & VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkBuildMicromapFlagBitsEXT(const VkBuildMicromapFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT";
        is_first = false;
    }
    if (object & VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkMicromapCreateFlagBitsEXT(const VkMicromapCreateFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSchedulingControlsFlagBitsARM(const VkPhysicalDeviceSchedulingControlsFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM";
        is_first = false;
    }
    if (object & VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkMemoryDecompressionMethodFlagBitsEXT(const VkMemoryDecompressionMethodFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkTensorCreateFlagBitsARM(const VkTensorCreateFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM";
        is_first = false;
    }
    if (object & VK_TENSOR_CREATE_PROTECTED_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_CREATE_PROTECTED_BIT_ARM";
        is_first = false;
    }
    if (object & VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM";
        is_first = false;
    }
    if (object & VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkTensorUsageFlagBitsARM(const VkTensorUsageFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_TENSOR_USAGE_SHADER_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_USAGE_SHADER_BIT_ARM";
        is_first = false;
    }
    if (object & VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM";
        is_first = false;
    }
    if (object & VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM";
        is_first = false;
    }
    if (object & VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM";
        is_first = false;
    }
    if (object & VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkOpticalFlowGridSizeFlagBitsNV(const VkOpticalFlowGridSizeFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkOpticalFlowUsageFlagBitsNV(const VkOpticalFlowUsageFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_USAGE_COST_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_COST_BIT_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkOpticalFlowSessionCreateFlagBitsNV(const VkOpticalFlowSessionCreateFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV";
        is_first = false;
    }
    if (object & VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkOpticalFlowExecuteFlagBitsNV(const VkOpticalFlowExecuteFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkShaderCreateFlagBitsEXT(const VkShaderCreateFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_SHADER_CREATE_LINK_STAGE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_LINK_STAGE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_INSTRUMENT_SHADER_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_INSTRUMENT_SHADER_BIT_ARM";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT";
        is_first = false;
    }
    if (object & VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSessionCreateFlagBitsARM(const VkDataGraphPipelineSessionCreateFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_OPTICAL_FLOW_CACHE_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_OPTICAL_FLOW_CACHE_BIT_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineDispatchFlagBitsARM(const VkDataGraphPipelineDispatchFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDataGraphTOSAQualityFlagBitsARM(const VkDataGraphTOSAQualityFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DATA_GRAPH_TOSA_QUALITY_ACCELERATED_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_TOSA_QUALITY_ACCELERATED_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_TOSA_QUALITY_CONFORMANT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_TOSA_QUALITY_CONFORMANT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_TOSA_QUALITY_EXPERIMENTAL_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_TOSA_QUALITY_EXPERIMENTAL_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_TOSA_QUALITY_DEPRECATED_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_TOSA_QUALITY_DEPRECATED_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureAddressResolutionFlagBitsNV(const VkClusterAccelerationStructureAddressResolutionFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV";
        is_first = false;
    }
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV";
        is_first = false;
    }
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV";
        is_first = false;
    }
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV";
        is_first = false;
    }
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV";
        is_first = false;
    }
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV";
        is_first = false;
    }
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureClusterFlagBitsNV(const VkClusterAccelerationStructureClusterFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureGeometryFlagBitsNV(const VkClusterAccelerationStructureGeometryFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV";
        is_first = false;
    }
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV";
        is_first = false;
    }
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureIndexFormatFlagBitsNV(const VkClusterAccelerationStructureIndexFormatFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV";
        is_first = false;
    }
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV";
        is_first = false;
    }
    if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkPartitionedAccelerationStructureInstanceFlagBitsNV(const VkPartitionedAccelerationStructureInstanceFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV";
        is_first = false;
    }
    if (object & VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV";
        is_first = false;
    }
    if (object & VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV";
        is_first = false;
    }
    if (object & VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV";
        is_first = false;
    }
    if (object & VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkIndirectCommandsInputModeFlagBitsEXT(const VkIndirectCommandsInputModeFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT";
        is_first = false;
    }
    if (object & VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkIndirectCommandsLayoutUsageFlagBitsEXT(const VkIndirectCommandsLayoutUsageFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT";
        is_first = false;
    }
    if (object & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDataGraphOpticalFlowGridSizeFlagBitsARM(const VkDataGraphOpticalFlowGridSizeFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDataGraphOpticalFlowCreateFlagBitsARM(const VkDataGraphOpticalFlowCreateFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_HINT_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_HINT_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_COST_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_COST_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_RESERVED_30_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_RESERVED_30_BIT_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDataGraphOpticalFlowImageUsageFlagBitsARM(const VkDataGraphOpticalFlowImageUsageFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object == VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_UNKNOWN_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_UNKNOWN_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_INPUT_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_INPUT_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_OUTPUT_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_OUTPUT_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_HINT_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_HINT_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_COST_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_COST_BIT_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_VkDataGraphOpticalFlowExecuteFlagBitsARM(const VkDataGraphOpticalFlowExecuteFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value_start<Format>(settings);
    settings.stream() << object;
    bool is_first = true;
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_UNCHANGED_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_UNCHANGED_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_UNCHANGED_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_UNCHANGED_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_IS_PREVIOUS_REFERENCE_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_IS_PREVIOUS_REFERENCE_BIT_ARM";
        is_first = false;
    }
    if (object & VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_IS_PREVIOUS_INPUT_BIT_ARM) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_IS_PREVIOUS_INPUT_BIT_ARM";
        is_first = false;
    }

    if (!is_first)
        settings.stream() << ")";
    dump_value_end<Format>(settings);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

//=========================== Flag Implementations ==========================//

template <ApiDumpFormat Format>
void dump_VkFormatFeatureFlags(const VkFormatFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkFormatFeatureFlagBits<Format>(static_cast<VkFormatFeatureFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkImageCreateFlags(const VkImageCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkImageCreateFlagBits<Format>(static_cast<VkImageCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSampleCountFlags(const VkSampleCountFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSampleCountFlagBits<Format>(static_cast<VkSampleCountFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkImageUsageFlags(const VkImageUsageFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkImageUsageFlagBits<Format>(static_cast<VkImageUsageFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkInstanceCreateFlags(const VkInstanceCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkInstanceCreateFlagBits<Format>(static_cast<VkInstanceCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkMemoryHeapFlags(const VkMemoryHeapFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkMemoryHeapFlagBits<Format>(static_cast<VkMemoryHeapFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkMemoryPropertyFlags(const VkMemoryPropertyFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkMemoryPropertyFlagBits<Format>(static_cast<VkMemoryPropertyFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkQueueFlags(const VkQueueFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkQueueFlagBits<Format>(static_cast<VkQueueFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkShaderStageFlags(const VkShaderStageFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkShaderStageFlagBits<Format>(static_cast<VkShaderStageFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDeviceCreateFlags(const VkDeviceCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceQueueCreateFlags(const VkDeviceQueueCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDeviceQueueCreateFlagBits<Format>(static_cast<VkDeviceQueueCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineStageFlags(const VkPipelineStageFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPipelineStageFlagBits<Format>(static_cast<VkPipelineStageFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkMemoryMapFlags(const VkMemoryMapFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkMemoryMapFlagBits<Format>(static_cast<VkMemoryMapFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkImageAspectFlags(const VkImageAspectFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkImageAspectFlagBits<Format>(static_cast<VkImageAspectFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSparseImageFormatFlags(const VkSparseImageFormatFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSparseImageFormatFlagBits<Format>(static_cast<VkSparseImageFormatFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSparseMemoryBindFlags(const VkSparseMemoryBindFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSparseMemoryBindFlagBits<Format>(static_cast<VkSparseMemoryBindFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkFenceCreateFlags(const VkFenceCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkFenceCreateFlagBits<Format>(static_cast<VkFenceCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreCreateFlags(const VkSemaphoreCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueryPoolCreateFlags(const VkQueryPoolCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkQueryPoolCreateFlagBits<Format>(static_cast<VkQueryPoolCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkQueryPipelineStatisticFlags(const VkQueryPipelineStatisticFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkQueryPipelineStatisticFlagBits<Format>(static_cast<VkQueryPipelineStatisticFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkQueryResultFlags(const VkQueryResultFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkQueryResultFlagBits<Format>(static_cast<VkQueryResultFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkBufferCreateFlags(const VkBufferCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkBufferCreateFlagBits<Format>(static_cast<VkBufferCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkBufferUsageFlags(const VkBufferUsageFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkBufferUsageFlagBits<Format>(static_cast<VkBufferUsageFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkImageViewCreateFlags(const VkImageViewCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkImageViewCreateFlagBits<Format>(static_cast<VkImageViewCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkAccessFlags(const VkAccessFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkAccessFlagBits<Format>(static_cast<VkAccessFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDependencyFlags(const VkDependencyFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDependencyFlagBits<Format>(static_cast<VkDependencyFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkCommandPoolCreateFlags(const VkCommandPoolCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkCommandPoolCreateFlagBits<Format>(static_cast<VkCommandPoolCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkCommandPoolResetFlags(const VkCommandPoolResetFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkCommandPoolResetFlagBits<Format>(static_cast<VkCommandPoolResetFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkQueryControlFlags(const VkQueryControlFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkQueryControlFlagBits<Format>(static_cast<VkQueryControlFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferUsageFlags(const VkCommandBufferUsageFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkCommandBufferUsageFlagBits<Format>(static_cast<VkCommandBufferUsageFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferResetFlags(const VkCommandBufferResetFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkCommandBufferResetFlagBits<Format>(static_cast<VkCommandBufferResetFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkEventCreateFlags(const VkEventCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkEventCreateFlagBits<Format>(static_cast<VkEventCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkBufferViewCreateFlags(const VkBufferViewCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderModuleCreateFlags(const VkShaderModuleCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCacheCreateFlags(const VkPipelineCacheCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPipelineCacheCreateFlagBits<Format>(static_cast<VkPipelineCacheCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCreateFlags(const VkPipelineCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPipelineCreateFlagBits<Format>(static_cast<VkPipelineCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineLayoutCreateFlags(const VkPipelineLayoutCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPipelineLayoutCreateFlagBits<Format>(static_cast<VkPipelineLayoutCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineShaderStageCreateFlags(const VkPipelineShaderStageCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPipelineShaderStageCreateFlagBits<Format>(static_cast<VkPipelineShaderStageCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSamplerCreateFlags(const VkSamplerCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSamplerCreateFlagBits<Format>(static_cast<VkSamplerCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorPoolCreateFlags(const VkDescriptorPoolCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDescriptorPoolCreateFlagBits<Format>(static_cast<VkDescriptorPoolCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorPoolResetFlags(const VkDescriptorPoolResetFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorSetLayoutCreateFlags(const VkDescriptorSetLayoutCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDescriptorSetLayoutCreateFlagBits<Format>(static_cast<VkDescriptorSetLayoutCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkColorComponentFlags(const VkColorComponentFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkColorComponentFlagBits<Format>(static_cast<VkColorComponentFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkCullModeFlags(const VkCullModeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkCullModeFlagBits<Format>(static_cast<VkCullModeFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineColorBlendStateCreateFlags(const VkPipelineColorBlendStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPipelineColorBlendStateCreateFlagBits<Format>(static_cast<VkPipelineColorBlendStateCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineDepthStencilStateCreateFlags(const VkPipelineDepthStencilStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPipelineDepthStencilStateCreateFlagBits<Format>(static_cast<VkPipelineDepthStencilStateCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineDynamicStateCreateFlags(const VkPipelineDynamicStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineInputAssemblyStateCreateFlags(const VkPipelineInputAssemblyStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineMultisampleStateCreateFlags(const VkPipelineMultisampleStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRasterizationStateCreateFlags(const VkPipelineRasterizationStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineTessellationStateCreateFlags(const VkPipelineTessellationStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineVertexInputStateCreateFlags(const VkPipelineVertexInputStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineViewportStateCreateFlags(const VkPipelineViewportStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentDescriptionFlags(const VkAttachmentDescriptionFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkAttachmentDescriptionFlagBits<Format>(static_cast<VkAttachmentDescriptionFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkFramebufferCreateFlags(const VkFramebufferCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkFramebufferCreateFlagBits<Format>(static_cast<VkFramebufferCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassCreateFlags(const VkRenderPassCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkRenderPassCreateFlagBits<Format>(static_cast<VkRenderPassCreateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSubpassDescriptionFlags(const VkSubpassDescriptionFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSubpassDescriptionFlagBits<Format>(static_cast<VkSubpassDescriptionFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkStencilFaceFlags(const VkStencilFaceFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkStencilFaceFlagBits<Format>(static_cast<VkStencilFaceFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSubgroupFeatureFlags(const VkSubgroupFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSubgroupFeatureFlagBits<Format>(static_cast<VkSubgroupFeatureFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPeerMemoryFeatureFlags(const VkPeerMemoryFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPeerMemoryFeatureFlagBits<Format>(static_cast<VkPeerMemoryFeatureFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkMemoryAllocateFlags(const VkMemoryAllocateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkMemoryAllocateFlagBits<Format>(static_cast<VkMemoryAllocateFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkCommandPoolTrimFlags(const VkCommandPoolTrimFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalMemoryHandleTypeFlags(const VkExternalMemoryHandleTypeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(static_cast<VkExternalMemoryHandleTypeFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkExternalMemoryFeatureFlags(const VkExternalMemoryFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkExternalMemoryFeatureFlagBits<Format>(static_cast<VkExternalMemoryFeatureFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkExternalFenceHandleTypeFlags(const VkExternalFenceHandleTypeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkExternalFenceHandleTypeFlagBits<Format>(static_cast<VkExternalFenceHandleTypeFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkExternalFenceFeatureFlags(const VkExternalFenceFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkExternalFenceFeatureFlagBits<Format>(static_cast<VkExternalFenceFeatureFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkFenceImportFlags(const VkFenceImportFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkFenceImportFlagBits<Format>(static_cast<VkFenceImportFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreImportFlags(const VkSemaphoreImportFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSemaphoreImportFlagBits<Format>(static_cast<VkSemaphoreImportFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkExternalSemaphoreHandleTypeFlags(const VkExternalSemaphoreHandleTypeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkExternalSemaphoreHandleTypeFlagBits<Format>(static_cast<VkExternalSemaphoreHandleTypeFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkExternalSemaphoreFeatureFlags(const VkExternalSemaphoreFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkExternalSemaphoreFeatureFlagBits<Format>(static_cast<VkExternalSemaphoreFeatureFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorUpdateTemplateCreateFlags(const VkDescriptorUpdateTemplateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkResolveModeFlags(const VkResolveModeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkResolveModeFlagBits<Format>(static_cast<VkResolveModeFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreWaitFlags(const VkSemaphoreWaitFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSemaphoreWaitFlagBits<Format>(static_cast<VkSemaphoreWaitFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorBindingFlags(const VkDescriptorBindingFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDescriptorBindingFlagBits<Format>(static_cast<VkDescriptorBindingFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkToolPurposeFlags(const VkToolPurposeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkToolPurposeFlagBits<Format>(static_cast<VkToolPurposeFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPrivateDataSlotCreateFlags(const VkPrivateDataSlotCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineStageFlags2(const VkPipelineStageFlags2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPipelineStageFlagBits2<Format>(static_cast<VkPipelineStageFlagBits2>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkAccessFlags2(const VkAccessFlags2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkAccessFlagBits2<Format>(static_cast<VkAccessFlagBits2>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSubmitFlags(const VkSubmitFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSubmitFlagBits<Format>(static_cast<VkSubmitFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkFormatFeatureFlags2(const VkFormatFeatureFlags2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkFormatFeatureFlagBits2<Format>(static_cast<VkFormatFeatureFlagBits2>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCreationFeedbackFlags(const VkPipelineCreationFeedbackFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPipelineCreationFeedbackFlagBits<Format>(static_cast<VkPipelineCreationFeedbackFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkRenderingFlags(const VkRenderingFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkRenderingFlagBits<Format>(static_cast<VkRenderingFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkMemoryUnmapFlags(const VkMemoryUnmapFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkMemoryUnmapFlagBits<Format>(static_cast<VkMemoryUnmapFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkBufferUsageFlags2(const VkBufferUsageFlags2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkBufferUsageFlagBits2<Format>(static_cast<VkBufferUsageFlagBits2>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkHostImageCopyFlags(const VkHostImageCopyFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkHostImageCopyFlagBits<Format>(static_cast<VkHostImageCopyFlagBits>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCreateFlags2(const VkPipelineCreateFlags2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPipelineCreateFlagBits2<Format>(static_cast<VkPipelineCreateFlagBits2>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceTransformFlagsKHR(const VkSurfaceTransformFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSurfaceTransformFlagBitsKHR<Format>(static_cast<VkSurfaceTransformFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkCompositeAlphaFlagsKHR(const VkCompositeAlphaFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkCompositeAlphaFlagBitsKHR<Format>(static_cast<VkCompositeAlphaFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainCreateFlagsKHR(const VkSwapchainCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSwapchainCreateFlagBitsKHR<Format>(static_cast<VkSwapchainCreateFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDeviceGroupPresentModeFlagsKHR(const VkDeviceGroupPresentModeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDeviceGroupPresentModeFlagBitsKHR<Format>(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDisplayModeCreateFlagsKHR(const VkDisplayModeCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayPlaneAlphaFlagsKHR(const VkDisplayPlaneAlphaFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDisplayPlaneAlphaFlagBitsKHR<Format>(static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDisplaySurfaceCreateFlagsKHR(const VkDisplaySurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#if defined(VK_USE_PLATFORM_XLIB_KHR)
template <ApiDumpFormat Format>
void dump_VkXlibSurfaceCreateFlagsKHR(const VkXlibSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)
template <ApiDumpFormat Format>
void dump_VkXcbSurfaceCreateFlagsKHR(const VkXcbSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
template <ApiDumpFormat Format>
void dump_VkWaylandSurfaceCreateFlagsKHR(const VkWaylandSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
template <ApiDumpFormat Format>
void dump_VkAndroidSurfaceCreateFlagsKHR(const VkAndroidSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
template <ApiDumpFormat Format>
void dump_VkWin32SurfaceCreateFlagsKHR(const VkWin32SurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR
template <ApiDumpFormat Format>
void dump_VkVideoCodecOperationFlagsKHR(const VkVideoCodecOperationFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoCodecOperationFlagBitsKHR<Format>(static_cast<VkVideoCodecOperationFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoChromaSubsamplingFlagsKHR(const VkVideoChromaSubsamplingFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoChromaSubsamplingFlagBitsKHR<Format>(static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoComponentBitDepthFlagsKHR(const VkVideoComponentBitDepthFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoComponentBitDepthFlagBitsKHR<Format>(static_cast<VkVideoComponentBitDepthFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoCapabilityFlagsKHR(const VkVideoCapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoCapabilityFlagBitsKHR<Format>(static_cast<VkVideoCapabilityFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoSessionCreateFlagsKHR(const VkVideoSessionCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoSessionCreateFlagBitsKHR<Format>(static_cast<VkVideoSessionCreateFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoSessionParametersCreateFlagsKHR(const VkVideoSessionParametersCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoSessionParametersCreateFlagBitsKHR<Format>(static_cast<VkVideoSessionParametersCreateFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoBeginCodingFlagsKHR(const VkVideoBeginCodingFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEndCodingFlagsKHR(const VkVideoEndCodingFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoCodingControlFlagsKHR(const VkVideoCodingControlFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoCodingControlFlagBitsKHR<Format>(static_cast<VkVideoCodingControlFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeCapabilityFlagsKHR(const VkVideoDecodeCapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoDecodeCapabilityFlagBitsKHR<Format>(static_cast<VkVideoDecodeCapabilityFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeUsageFlagsKHR(const VkVideoDecodeUsageFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoDecodeUsageFlagBitsKHR<Format>(static_cast<VkVideoDecodeUsageFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeFlagsKHR(const VkVideoDecodeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264CapabilityFlagsKHR(const VkVideoEncodeH264CapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeH264CapabilityFlagBitsKHR<Format>(static_cast<VkVideoEncodeH264CapabilityFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264StdFlagsKHR(const VkVideoEncodeH264StdFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeH264StdFlagBitsKHR<Format>(static_cast<VkVideoEncodeH264StdFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264RateControlFlagsKHR(const VkVideoEncodeH264RateControlFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeH264RateControlFlagBitsKHR<Format>(static_cast<VkVideoEncodeH264RateControlFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265CapabilityFlagsKHR(const VkVideoEncodeH265CapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeH265CapabilityFlagBitsKHR<Format>(static_cast<VkVideoEncodeH265CapabilityFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265StdFlagsKHR(const VkVideoEncodeH265StdFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeH265StdFlagBitsKHR<Format>(static_cast<VkVideoEncodeH265StdFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265CtbSizeFlagsKHR(const VkVideoEncodeH265CtbSizeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeH265CtbSizeFlagBitsKHR<Format>(static_cast<VkVideoEncodeH265CtbSizeFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265TransformBlockSizeFlagsKHR(const VkVideoEncodeH265TransformBlockSizeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeH265TransformBlockSizeFlagBitsKHR<Format>(static_cast<VkVideoEncodeH265TransformBlockSizeFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265RateControlFlagsKHR(const VkVideoEncodeH265RateControlFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeH265RateControlFlagBitsKHR<Format>(static_cast<VkVideoEncodeH265RateControlFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH264PictureLayoutFlagsKHR(const VkVideoDecodeH264PictureLayoutFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoDecodeH264PictureLayoutFlagBitsKHR<Format>(static_cast<VkVideoDecodeH264PictureLayoutFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceCounterDescriptionFlagsKHR(const VkPerformanceCounterDescriptionFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPerformanceCounterDescriptionFlagBitsKHR<Format>(static_cast<VkPerformanceCounterDescriptionFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkAcquireProfilingLockFlagsKHR(const VkAcquireProfilingLockFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkAcquireProfilingLockFlagBitsKHR<Format>(static_cast<VkAcquireProfilingLockFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeFlagsKHR(const VkVideoEncodeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeFlagBitsKHR<Format>(static_cast<VkVideoEncodeFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeCapabilityFlagsKHR(const VkVideoEncodeCapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeCapabilityFlagBitsKHR<Format>(static_cast<VkVideoEncodeCapabilityFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeRateControlModeFlagsKHR(const VkVideoEncodeRateControlModeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeRateControlModeFlagBitsKHR<Format>(static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeFeedbackFlagsKHR(const VkVideoEncodeFeedbackFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeFeedbackFlagBitsKHR<Format>(static_cast<VkVideoEncodeFeedbackFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeUsageFlagsKHR(const VkVideoEncodeUsageFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeUsageFlagBitsKHR<Format>(static_cast<VkVideoEncodeUsageFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeContentFlagsKHR(const VkVideoEncodeContentFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeContentFlagBitsKHR<Format>(static_cast<VkVideoEncodeContentFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeRateControlFlagsKHR(const VkVideoEncodeRateControlFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAddressCommandFlagsKHR(const VkAddressCommandFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkAddressCommandFlagBitsKHR<Format>(static_cast<VkAddressCommandFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkConditionalRenderingFlagsEXT(const VkConditionalRenderingFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkConditionalRenderingFlagBitsEXT<Format>(static_cast<VkConditionalRenderingFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureCreateFlagsKHR(const VkAccelerationStructureCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkAccelerationStructureCreateFlagBitsKHR<Format>(static_cast<VkAccelerationStructureCreateFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPresentScalingFlagsKHR(const VkPresentScalingFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPresentScalingFlagBitsKHR<Format>(static_cast<VkPresentScalingFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPresentGravityFlagsKHR(const VkPresentGravityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPresentGravityFlagBitsKHR<Format>(static_cast<VkPresentGravityFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1CapabilityFlagsKHR(const VkVideoEncodeAV1CapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeAV1CapabilityFlagBitsKHR<Format>(static_cast<VkVideoEncodeAV1CapabilityFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1StdFlagsKHR(const VkVideoEncodeAV1StdFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeAV1StdFlagBitsKHR<Format>(static_cast<VkVideoEncodeAV1StdFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1SuperblockSizeFlagsKHR(const VkVideoEncodeAV1SuperblockSizeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR<Format>(static_cast<VkVideoEncodeAV1SuperblockSizeFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1RateControlFlagsKHR(const VkVideoEncodeAV1RateControlFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeAV1RateControlFlagBitsKHR<Format>(static_cast<VkVideoEncodeAV1RateControlFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkAddressCopyFlagsKHR(const VkAddressCopyFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkAddressCopyFlagBitsKHR<Format>(static_cast<VkAddressCopyFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeIntraRefreshModeFlagsKHR(const VkVideoEncodeIntraRefreshModeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeIntraRefreshModeFlagBitsKHR<Format>(static_cast<VkVideoEncodeIntraRefreshModeFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDeviceFaultFlagsKHR(const VkDeviceFaultFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDeviceFaultFlagBitsKHR<Format>(static_cast<VkDeviceFaultFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkAccessFlags3KHR(const VkAccessFlags3KHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkAccessFlagBits3KHR<Format>(static_cast<VkAccessFlagBits3KHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodePerPartitionFeedbackFlagsKHR(const VkVideoEncodePerPartitionFeedbackFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodePerPartitionFeedbackFlagBitsKHR<Format>(static_cast<VkVideoEncodePerPartitionFeedbackFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkRenderingAttachmentFlagsKHR(const VkRenderingAttachmentFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkRenderingAttachmentFlagBitsKHR<Format>(static_cast<VkRenderingAttachmentFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkResolveImageFlagsKHR(const VkResolveImageFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkResolveImageFlagBitsKHR<Format>(static_cast<VkResolveImageFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkFormatFeatureFlags4KHR(const VkFormatFeatureFlags4KHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkFormatFeatureFlagBits4KHR<Format>(static_cast<VkFormatFeatureFlagBits4KHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkImageUsageFlags2KHR(const VkImageUsageFlags2KHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkImageUsageFlagBits2KHR<Format>(static_cast<VkImageUsageFlagBits2KHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkImageCreateFlags2KHR(const VkImageCreateFlags2KHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkImageCreateFlagBits2KHR<Format>(static_cast<VkImageCreateFlagBits2KHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDebugReportFlagsEXT(const VkDebugReportFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDebugReportFlagBitsEXT<Format>(static_cast<VkDebugReportFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRasterizationStateStreamCreateFlagsEXT(const VkPipelineRasterizationStateStreamCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#if defined(VK_USE_PLATFORM_GGP)
template <ApiDumpFormat Format>
void dump_VkStreamDescriptorSurfaceCreateFlagsGGP(const VkStreamDescriptorSurfaceCreateFlagsGGP object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_GGP
template <ApiDumpFormat Format>
void dump_VkExternalMemoryHandleTypeFlagsNV(const VkExternalMemoryHandleTypeFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkExternalMemoryHandleTypeFlagBitsNV<Format>(static_cast<VkExternalMemoryHandleTypeFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkExternalMemoryFeatureFlagsNV(const VkExternalMemoryFeatureFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkExternalMemoryFeatureFlagBitsNV<Format>(static_cast<VkExternalMemoryFeatureFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
#if defined(VK_USE_PLATFORM_VI_NN)
template <ApiDumpFormat Format>
void dump_VkViSurfaceCreateFlagsNN(const VkViSurfaceCreateFlagsNN object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_VI_NN
template <ApiDumpFormat Format>
void dump_VkSurfaceCounterFlagsEXT(const VkSurfaceCounterFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSurfaceCounterFlagBitsEXT<Format>(static_cast<VkSurfaceCounterFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineViewportSwizzleStateCreateFlagsNV(const VkPipelineViewportSwizzleStateCreateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineDiscardRectangleStateCreateFlagsEXT(const VkPipelineDiscardRectangleStateCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRasterizationConservativeStateCreateFlagsEXT(const VkPipelineRasterizationConservativeStateCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(const VkPipelineRasterizationDepthClipStateCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#if defined(VK_USE_PLATFORM_IOS_MVK)
template <ApiDumpFormat Format>
void dump_VkIOSSurfaceCreateFlagsMVK(const VkIOSSurfaceCreateFlagsMVK object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_IOS_MVK
#if defined(VK_USE_PLATFORM_MACOS_MVK)
template <ApiDumpFormat Format>
void dump_VkMacOSSurfaceCreateFlagsMVK(const VkMacOSSurfaceCreateFlagsMVK object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_MACOS_MVK
template <ApiDumpFormat Format>
void dump_VkDebugUtilsMessengerCallbackDataFlagsEXT(const VkDebugUtilsMessengerCallbackDataFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDebugUtilsMessageTypeFlagsEXT(const VkDebugUtilsMessageTypeFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDebugUtilsMessageTypeFlagBitsEXT<Format>(static_cast<VkDebugUtilsMessageTypeFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDebugUtilsMessageSeverityFlagsEXT(const VkDebugUtilsMessageSeverityFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDebugUtilsMessageSeverityFlagBitsEXT<Format>(static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDebugUtilsMessengerCreateFlagsEXT(const VkDebugUtilsMessengerCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkGpaSqShaderStageFlagsAMD(const VkGpaSqShaderStageFlagsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkGpaSqShaderStageFlagBitsAMD<Format>(static_cast<VkGpaSqShaderStageFlagBitsAMD>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkGpaPerfBlockPropertiesFlagsAMD(const VkGpaPerfBlockPropertiesFlagsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceGpaPropertiesFlagsAMD(const VkPhysicalDeviceGpaPropertiesFlagsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorViewCreateFlagsARM(const VkTensorViewCreateFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkTensorViewCreateFlagBitsARM<Format>(static_cast<VkTensorViewCreateFlagBitsARM>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkSpirvResourceTypeFlagsEXT(const VkSpirvResourceTypeFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkSpirvResourceTypeFlagBitsEXT<Format>(static_cast<VkSpirvResourceTypeFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCoverageToColorStateCreateFlagsNV(const VkPipelineCoverageToColorStateCreateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCoverageModulationStateCreateFlagsNV(const VkPipelineCoverageModulationStateCreateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkValidationCacheCreateFlagsEXT(const VkValidationCacheCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeometryFlagsKHR(const VkGeometryFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkGeometryFlagBitsKHR<Format>(static_cast<VkGeometryFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkGeometryInstanceFlagsKHR(const VkGeometryInstanceFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkGeometryInstanceFlagBitsKHR<Format>(static_cast<VkGeometryInstanceFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkBuildAccelerationStructureFlagsKHR(const VkBuildAccelerationStructureFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkBuildAccelerationStructureFlagBitsKHR<Format>(static_cast<VkBuildAccelerationStructureFlagBitsKHR>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCompilerControlFlagsAMD(const VkPipelineCompilerControlFlagsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPipelineCompilerControlFlagBitsAMD<Format>(static_cast<VkPipelineCompilerControlFlagBitsAMD>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPresentStageFlagsEXT(const VkPresentStageFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPresentStageFlagBitsEXT<Format>(static_cast<VkPresentStageFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPastPresentationTimingFlagsEXT(const VkPastPresentationTimingFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPastPresentationTimingFlagBitsEXT<Format>(static_cast<VkPastPresentationTimingFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPresentTimingInfoFlagsEXT(const VkPresentTimingInfoFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPresentTimingInfoFlagBitsEXT<Format>(static_cast<VkPresentTimingInfoFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
#if defined(VK_USE_PLATFORM_FUCHSIA)
template <ApiDumpFormat Format>
void dump_VkImagePipeSurfaceCreateFlagsFUCHSIA(const VkImagePipeSurfaceCreateFlagsFUCHSIA object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_METAL_EXT)
template <ApiDumpFormat Format>
void dump_VkMetalSurfaceCreateFlagsEXT(const VkMetalSurfaceCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_METAL_EXT
template <ApiDumpFormat Format>
void dump_VkShaderCorePropertiesFlagsAMD(const VkShaderCorePropertiesFlagsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkShaderCorePropertiesFlagBitsAMD<Format>(static_cast<VkShaderCorePropertiesFlagBitsAMD>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCoverageReductionStateCreateFlagsNV(const VkPipelineCoverageReductionStateCreateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkHeadlessSurfaceCreateFlagsEXT(const VkHeadlessSurfaceCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectStateFlagsNV(const VkIndirectStateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkIndirectStateFlagBitsNV<Format>(static_cast<VkIndirectStateFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsLayoutUsageFlagsNV(const VkIndirectCommandsLayoutUsageFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkIndirectCommandsLayoutUsageFlagBitsNV<Format>(static_cast<VkIndirectCommandsLayoutUsageFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDeviceMemoryReportFlagsEXT(const VkDeviceMemoryReportFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceDiagnosticsConfigFlagsNV(const VkDeviceDiagnosticsConfigFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDeviceDiagnosticsConfigFlagBitsNV<Format>(static_cast<VkDeviceDiagnosticsConfigFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkTileShadingRenderPassFlagsQCOM(const VkTileShadingRenderPassFlagsQCOM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkTileShadingRenderPassFlagBitsQCOM<Format>(static_cast<VkTileShadingRenderPassFlagBitsQCOM>(object), settings, type_name, var_name, indents, address);
}
#if defined(VK_USE_PLATFORM_METAL_EXT)
template <ApiDumpFormat Format>
void dump_VkExportMetalObjectTypeFlagsEXT(const VkExportMetalObjectTypeFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkExportMetalObjectTypeFlagBitsEXT<Format>(static_cast<VkExportMetalObjectTypeFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
#endif  // VK_USE_PLATFORM_METAL_EXT
template <ApiDumpFormat Format>
void dump_VkGraphicsPipelineLibraryFlagsEXT(const VkGraphicsPipelineLibraryFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkGraphicsPipelineLibraryFlagBitsEXT<Format>(static_cast<VkGraphicsPipelineLibraryFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureMotionInfoFlagsNV(const VkAccelerationStructureMotionInfoFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureMotionInstanceFlagsNV(const VkAccelerationStructureMotionInstanceFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageCompressionFlagsEXT(const VkImageCompressionFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkImageCompressionFlagBitsEXT<Format>(static_cast<VkImageCompressionFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkImageCompressionFixedRateFlagsEXT(const VkImageCompressionFixedRateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkImageCompressionFixedRateFlagBitsEXT<Format>(static_cast<VkImageCompressionFixedRateFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
template <ApiDumpFormat Format>
void dump_VkDirectFBSurfaceCreateFlagsEXT(const VkDirectFBSurfaceCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_DIRECTFB_EXT
template <ApiDumpFormat Format>
void dump_VkDeviceAddressBindingFlagsEXT(const VkDeviceAddressBindingFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDeviceAddressBindingFlagBitsEXT<Format>(static_cast<VkDeviceAddressBindingFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
#if defined(VK_USE_PLATFORM_FUCHSIA)
template <ApiDumpFormat Format>
void dump_VkImageFormatConstraintsFlagsFUCHSIA(const VkImageFormatConstraintsFlagsFUCHSIA object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageConstraintsInfoFlagsFUCHSIA(const VkImageConstraintsInfoFlagsFUCHSIA object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkImageConstraintsInfoFlagBitsFUCHSIA<Format>(static_cast<VkImageConstraintsInfoFlagBitsFUCHSIA>(object), settings, type_name, var_name, indents, address);
}
#endif  // VK_USE_PLATFORM_FUCHSIA
template <ApiDumpFormat Format>
void dump_VkFrameBoundaryFlagsEXT(const VkFrameBoundaryFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkFrameBoundaryFlagBitsEXT<Format>(static_cast<VkFrameBoundaryFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
template <ApiDumpFormat Format>
void dump_VkScreenSurfaceCreateFlagsQNX(const VkScreenSurfaceCreateFlagsQNX object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_SCREEN_QNX
template <ApiDumpFormat Format>
void dump_VkVideoEncodeRgbModelConversionFlagsVALVE(const VkVideoEncodeRgbModelConversionFlagsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeRgbModelConversionFlagBitsVALVE<Format>(static_cast<VkVideoEncodeRgbModelConversionFlagBitsVALVE>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeRgbRangeCompressionFlagsVALVE(const VkVideoEncodeRgbRangeCompressionFlagsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE<Format>(static_cast<VkVideoEncodeRgbRangeCompressionFlagBitsVALVE>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeRgbChromaOffsetFlagsVALVE(const VkVideoEncodeRgbChromaOffsetFlagsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE<Format>(static_cast<VkVideoEncodeRgbChromaOffsetFlagBitsVALVE>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkBuildMicromapFlagsEXT(const VkBuildMicromapFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkBuildMicromapFlagBitsEXT<Format>(static_cast<VkBuildMicromapFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkMicromapCreateFlagsEXT(const VkMicromapCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkMicromapCreateFlagBitsEXT<Format>(static_cast<VkMicromapCreateFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSchedulingControlsFlagsARM(const VkPhysicalDeviceSchedulingControlsFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPhysicalDeviceSchedulingControlsFlagBitsARM<Format>(static_cast<VkPhysicalDeviceSchedulingControlsFlagBitsARM>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkMemoryDecompressionMethodFlagsEXT(const VkMemoryDecompressionMethodFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkMemoryDecompressionMethodFlagBitsEXT<Format>(static_cast<VkMemoryDecompressionMethodFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDirectDriverLoadingFlagsLUNARG(const VkDirectDriverLoadingFlagsLUNARG object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorCreateFlagsARM(const VkTensorCreateFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkTensorCreateFlagBitsARM<Format>(static_cast<VkTensorCreateFlagBitsARM>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkTensorUsageFlagsARM(const VkTensorUsageFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkTensorUsageFlagBitsARM<Format>(static_cast<VkTensorUsageFlagBitsARM>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkOpticalFlowGridSizeFlagsNV(const VkOpticalFlowGridSizeFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkOpticalFlowGridSizeFlagBitsNV<Format>(static_cast<VkOpticalFlowGridSizeFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkOpticalFlowUsageFlagsNV(const VkOpticalFlowUsageFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkOpticalFlowUsageFlagBitsNV<Format>(static_cast<VkOpticalFlowUsageFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkOpticalFlowSessionCreateFlagsNV(const VkOpticalFlowSessionCreateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkOpticalFlowSessionCreateFlagBitsNV<Format>(static_cast<VkOpticalFlowSessionCreateFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkOpticalFlowExecuteFlagsNV(const VkOpticalFlowExecuteFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkOpticalFlowExecuteFlagBitsNV<Format>(static_cast<VkOpticalFlowExecuteFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkShaderCreateFlagsEXT(const VkShaderCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkShaderCreateFlagBitsEXT<Format>(static_cast<VkShaderCreateFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSessionCreateFlagsARM(const VkDataGraphPipelineSessionCreateFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDataGraphPipelineSessionCreateFlagBitsARM<Format>(static_cast<VkDataGraphPipelineSessionCreateFlagBitsARM>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineDispatchFlagsARM(const VkDataGraphPipelineDispatchFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDataGraphPipelineDispatchFlagBitsARM<Format>(static_cast<VkDataGraphPipelineDispatchFlagBitsARM>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphTOSAQualityFlagsARM(const VkDataGraphTOSAQualityFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDataGraphTOSAQualityFlagBitsARM<Format>(static_cast<VkDataGraphTOSAQualityFlagBitsARM>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureAddressResolutionFlagsNV(const VkClusterAccelerationStructureAddressResolutionFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkClusterAccelerationStructureAddressResolutionFlagBitsNV<Format>(static_cast<VkClusterAccelerationStructureAddressResolutionFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureClusterFlagsNV(const VkClusterAccelerationStructureClusterFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkClusterAccelerationStructureClusterFlagBitsNV<Format>(static_cast<VkClusterAccelerationStructureClusterFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureGeometryFlagsNV(const VkClusterAccelerationStructureGeometryFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkClusterAccelerationStructureGeometryFlagBitsNV<Format>(static_cast<VkClusterAccelerationStructureGeometryFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureIndexFormatFlagsNV(const VkClusterAccelerationStructureIndexFormatFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkClusterAccelerationStructureIndexFormatFlagBitsNV<Format>(static_cast<VkClusterAccelerationStructureIndexFormatFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkPartitionedAccelerationStructureInstanceFlagsNV(const VkPartitionedAccelerationStructureInstanceFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkPartitionedAccelerationStructureInstanceFlagBitsNV<Format>(static_cast<VkPartitionedAccelerationStructureInstanceFlagBitsNV>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsInputModeFlagsEXT(const VkIndirectCommandsInputModeFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkIndirectCommandsInputModeFlagBitsEXT<Format>(static_cast<VkIndirectCommandsInputModeFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsLayoutUsageFlagsEXT(const VkIndirectCommandsLayoutUsageFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkIndirectCommandsLayoutUsageFlagBitsEXT<Format>(static_cast<VkIndirectCommandsLayoutUsageFlagBitsEXT>(object), settings, type_name, var_name, indents, address);
}
#if defined(VK_USE_PLATFORM_OHOS)
template <ApiDumpFormat Format>
void dump_VkSurfaceCreateFlagsOHOS(const VkSurfaceCreateFlagsOHOS object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_OHOS
template <ApiDumpFormat Format>
void dump_VkPerformanceCounterDescriptionFlagsARM(const VkPerformanceCounterDescriptionFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderInstrumentationValuesFlagsARM(const VkShaderInstrumentationValuesFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphOpticalFlowGridSizeFlagsARM(const VkDataGraphOpticalFlowGridSizeFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDataGraphOpticalFlowGridSizeFlagBitsARM<Format>(static_cast<VkDataGraphOpticalFlowGridSizeFlagBitsARM>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphOpticalFlowCreateFlagsARM(const VkDataGraphOpticalFlowCreateFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDataGraphOpticalFlowCreateFlagBitsARM<Format>(static_cast<VkDataGraphOpticalFlowCreateFlagBitsARM>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphOpticalFlowImageUsageFlagsARM(const VkDataGraphOpticalFlowImageUsageFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDataGraphOpticalFlowImageUsageFlagBitsARM<Format>(static_cast<VkDataGraphOpticalFlowImageUsageFlagBitsARM>(object), settings, type_name, var_name, indents, address);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphOpticalFlowExecuteFlagsARM(const VkDataGraphOpticalFlowExecuteFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_VkDataGraphOpticalFlowExecuteFlagBitsARM<Format>(static_cast<VkDataGraphOpticalFlowExecuteFlagBitsARM>(object), settings, type_name, var_name, indents, address);
}
#if defined(VK_USE_PLATFORM_UBM_SEC)
template <ApiDumpFormat Format>
void dump_VkUbmSurfaceCreateFlagsSEC(const VkUbmSurfaceCreateFlagsSEC object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_value<Format>(settings, object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
#endif  // VK_USE_PLATFORM_UBM_SEC

//======================= Func Pointer Implementations ======================//

template <ApiDumpFormat Format>
void dump_PFN_vkAllocationFunction(const PFN_vkAllocationFunction object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_address<Format>(settings, &object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_PFN_vkFreeFunction(const PFN_vkFreeFunction object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_address<Format>(settings, &object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_PFN_vkInternalAllocationNotification(const PFN_vkInternalAllocationNotification object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_address<Format>(settings, &object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_PFN_vkInternalFreeNotification(const PFN_vkInternalFreeNotification object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_address<Format>(settings, &object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_PFN_vkReallocationFunction(const PFN_vkReallocationFunction object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_address<Format>(settings, &object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_PFN_vkVoidFunction(const PFN_vkVoidFunction object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_address<Format>(settings, &object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_PFN_vkDebugReportCallbackEXT(const PFN_vkDebugReportCallbackEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_address<Format>(settings, &object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_PFN_vkDebugUtilsMessengerCallbackEXT(const PFN_vkDebugUtilsMessengerCallbackEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_address<Format>(settings, &object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_PFN_vkDeviceMemoryReportCallbackEXT(const PFN_vkDeviceMemoryReportCallbackEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_address<Format>(settings, &object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}
template <ApiDumpFormat Format>
void dump_PFN_vkGetInstanceProcAddrLUNARG(const PFN_vkGetInstanceProcAddrLUNARG object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents, address);
    dump_address<Format>(settings, &object);
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

//=================== Video Struct and Union Implementations ==================//

template <ApiDumpFormat Format>
void dump_StdVideoH264SpsVuiFlags(const StdVideoH264SpsVuiFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.aspect_ratio_info_present_flag, settings, "uint32_t: 1", "aspect_ratio_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.overscan_info_present_flag, settings, "uint32_t: 1", "overscan_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.overscan_appropriate_flag, settings, "uint32_t: 1", "overscan_appropriate_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.video_signal_type_present_flag, settings, "uint32_t: 1", "video_signal_type_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.video_full_range_flag, settings, "uint32_t: 1", "video_full_range_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.color_description_present_flag, settings, "uint32_t: 1", "color_description_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_loc_info_present_flag, settings, "uint32_t: 1", "chroma_loc_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.timing_info_present_flag, settings, "uint32_t: 1", "timing_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.fixed_frame_rate_flag, settings, "uint32_t: 1", "fixed_frame_rate_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bitstream_restriction_flag, settings, "uint32_t: 1", "bitstream_restriction_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.nal_hrd_parameters_present_flag, settings, "uint32_t: 1", "nal_hrd_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vcl_hrd_parameters_present_flag, settings, "uint32_t: 1", "vcl_hrd_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264HrdParameters(const StdVideoH264HrdParameters& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.cpb_cnt_minus1, settings, "uint8_t", "cpb_cnt_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bit_rate_scale, settings, "uint8_t", "bit_rate_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cpb_size_scale, settings, "uint8_t", "cpb_size_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.bit_rate_value_minus1, STD_VIDEO_H264_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]", "bit_rate_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.cpb_size_value_minus1, STD_VIDEO_H264_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]", "cpb_size_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.cbr_flag, STD_VIDEO_H264_CPB_CNT_LIST_SIZE, settings, "uint8_t[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]", "cbr_flag", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.initial_cpb_removal_delay_length_minus1, settings, "uint32_t", "initial_cpb_removal_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cpb_removal_delay_length_minus1, settings, "uint32_t", "cpb_removal_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dpb_output_delay_length_minus1, settings, "uint32_t", "dpb_output_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.time_offset_length, settings, "uint32_t", "time_offset_length", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264SequenceParameterSetVui(const StdVideoH264SequenceParameterSetVui& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoH264SpsVuiFlags<Format>(object.flags, settings, "StdVideoH264SpsVuiFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264AspectRatioIdc<Format>(object.aspect_ratio_idc, settings, "StdVideoH264AspectRatioIdc", "aspect_ratio_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.sar_width, settings, "uint16_t", "sar_width", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.sar_height, settings, "uint16_t", "sar_height", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.video_format, settings, "uint8_t", "video_format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colour_primaries, settings, "uint8_t", "colour_primaries", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.transfer_characteristics, settings, "uint8_t", "transfer_characteristics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.matrix_coefficients, settings, "uint8_t", "matrix_coefficients", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_units_in_tick, settings, "uint32_t", "num_units_in_tick", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.time_scale, settings, "uint32_t", "time_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.max_num_reorder_frames, settings, "uint8_t", "max_num_reorder_frames", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.max_dec_frame_buffering, settings, "uint8_t", "max_dec_frame_buffering", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_sample_loc_type_top_field, settings, "uint8_t", "chroma_sample_loc_type_top_field", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_sample_loc_type_bottom_field, settings, "uint8_t", "chroma_sample_loc_type_bottom_field", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint32_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pHrdParameters, settings, "const StdVideoH264HrdParameters*", "pHrdParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264HrdParameters<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264SpsFlags(const StdVideoH264SpsFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.constraint_set0_flag, settings, "uint32_t: 1", "constraint_set0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.constraint_set1_flag, settings, "uint32_t: 1", "constraint_set1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.constraint_set2_flag, settings, "uint32_t: 1", "constraint_set2_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.constraint_set3_flag, settings, "uint32_t: 1", "constraint_set3_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.constraint_set4_flag, settings, "uint32_t: 1", "constraint_set4_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.constraint_set5_flag, settings, "uint32_t: 1", "constraint_set5_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.direct_8x8_inference_flag, settings, "uint32_t: 1", "direct_8x8_inference_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.mb_adaptive_frame_field_flag, settings, "uint32_t: 1", "mb_adaptive_frame_field_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_mbs_only_flag, settings, "uint32_t: 1", "frame_mbs_only_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_pic_order_always_zero_flag, settings, "uint32_t: 1", "delta_pic_order_always_zero_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.separate_colour_plane_flag, settings, "uint32_t: 1", "separate_colour_plane_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gaps_in_frame_num_value_allowed_flag, settings, "uint32_t: 1", "gaps_in_frame_num_value_allowed_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.qpprime_y_zero_transform_bypass_flag, settings, "uint32_t: 1", "qpprime_y_zero_transform_bypass_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_cropping_flag, settings, "uint32_t: 1", "frame_cropping_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.seq_scaling_matrix_present_flag, settings, "uint32_t: 1", "seq_scaling_matrix_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vui_parameters_present_flag, settings, "uint32_t: 1", "vui_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264ScalingLists(const StdVideoH264ScalingLists& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint16_t>(object.scaling_list_present_mask, settings, "uint16_t", "scaling_list_present_mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.use_default_scaling_matrix_mask, settings, "uint16_t", "use_default_scaling_matrix_mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.ScalingList4x4, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS]", "ScalingList4x4", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.ScalingList8x8, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS]", "ScalingList8x8", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264SequenceParameterSet(const StdVideoH264SequenceParameterSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoH264SpsFlags<Format>(object.flags, settings, "StdVideoH264SpsFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264ProfileIdc<Format>(object.profile_idc, settings, "StdVideoH264ProfileIdc", "profile_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264LevelIdc<Format>(object.level_idc, settings, "StdVideoH264LevelIdc", "level_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264ChromaFormatIdc<Format>(object.chroma_format_idc, settings, "StdVideoH264ChromaFormatIdc", "chroma_format_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.seq_parameter_set_id, settings, "uint8_t", "seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bit_depth_luma_minus8, settings, "uint8_t", "bit_depth_luma_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bit_depth_chroma_minus8, settings, "uint8_t", "bit_depth_chroma_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_max_frame_num_minus4, settings, "uint8_t", "log2_max_frame_num_minus4", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264PocType<Format>(object.pic_order_cnt_type, settings, "StdVideoH264PocType", "pic_order_cnt_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.offset_for_non_ref_pic, settings, "int32_t", "offset_for_non_ref_pic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.offset_for_top_to_bottom_field, settings, "int32_t", "offset_for_top_to_bottom_field", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_max_pic_order_cnt_lsb_minus4, settings, "uint8_t", "log2_max_pic_order_cnt_lsb_minus4", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ref_frames_in_pic_order_cnt_cycle, settings, "uint8_t", "num_ref_frames_in_pic_order_cnt_cycle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.max_num_ref_frames, settings, "uint8_t", "max_num_ref_frames", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pic_width_in_mbs_minus1, settings, "uint32_t", "pic_width_in_mbs_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pic_height_in_map_units_minus1, settings, "uint32_t", "pic_height_in_map_units_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_crop_left_offset, settings, "uint32_t", "frame_crop_left_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_crop_right_offset, settings, "uint32_t", "frame_crop_right_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_crop_top_offset, settings, "uint32_t", "frame_crop_top_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_crop_bottom_offset, settings, "uint32_t", "frame_crop_bottom_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved2, settings, "uint32_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pOffsetForRefFrame, object.num_ref_frames_in_pic_order_cnt_cycle, settings, "const int32_t*", "pOffsetForRefFrame", "const int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const int32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pScalingLists, settings, "const StdVideoH264ScalingLists*", "pScalingLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264ScalingLists<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSequenceParameterSetVui, settings, "const StdVideoH264SequenceParameterSetVui*", "pSequenceParameterSetVui", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSetVui<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264PpsFlags(const StdVideoH264PpsFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.transform_8x8_mode_flag, settings, "uint32_t: 1", "transform_8x8_mode_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.redundant_pic_cnt_present_flag, settings, "uint32_t: 1", "redundant_pic_cnt_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.constrained_intra_pred_flag, settings, "uint32_t: 1", "constrained_intra_pred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deblocking_filter_control_present_flag, settings, "uint32_t: 1", "deblocking_filter_control_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.weighted_pred_flag, settings, "uint32_t: 1", "weighted_pred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bottom_field_pic_order_in_frame_present_flag, settings, "uint32_t: 1", "bottom_field_pic_order_in_frame_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.entropy_coding_mode_flag, settings, "uint32_t: 1", "entropy_coding_mode_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pic_scaling_matrix_present_flag, settings, "uint32_t: 1", "pic_scaling_matrix_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH264PictureParameterSet(const StdVideoH264PictureParameterSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoH264PpsFlags<Format>(object.flags, settings, "StdVideoH264PpsFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.seq_parameter_set_id, settings, "uint8_t", "seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pic_parameter_set_id, settings, "uint8_t", "pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ref_idx_l0_default_active_minus1, settings, "uint8_t", "num_ref_idx_l0_default_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ref_idx_l1_default_active_minus1, settings, "uint8_t", "num_ref_idx_l1_default_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264WeightedBipredIdc<Format>(object.weighted_bipred_idc, settings, "StdVideoH264WeightedBipredIdc", "weighted_bipred_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.pic_init_qp_minus26, settings, "int8_t", "pic_init_qp_minus26", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.pic_init_qs_minus26, settings, "int8_t", "pic_init_qs_minus26", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.chroma_qp_index_offset, settings, "int8_t", "chroma_qp_index_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.second_chroma_qp_index_offset, settings, "int8_t", "second_chroma_qp_index_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pScalingLists, settings, "const StdVideoH264ScalingLists*", "pScalingLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264ScalingLists<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeH264PictureInfoFlags(const StdVideoDecodeH264PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.field_pic_flag, settings, "uint32_t: 1", "field_pic_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.is_intra, settings, "uint32_t: 1", "is_intra", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.IdrPicFlag, settings, "uint32_t: 1", "IdrPicFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bottom_field_flag, settings, "uint32_t: 1", "bottom_field_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.is_reference, settings, "uint32_t: 1", "is_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.complementary_field_pair, settings, "uint32_t: 1", "complementary_field_pair", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeH264PictureInfo(const StdVideoDecodeH264PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoDecodeH264PictureInfoFlags<Format>(object.flags, settings, "StdVideoDecodeH264PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.seq_parameter_set_id, settings, "uint8_t", "seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pic_parameter_set_id, settings, "uint8_t", "pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.frame_num, settings, "uint16_t", "frame_num", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.idr_pic_id, settings, "uint16_t", "idr_pic_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.PicOrderCnt, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE, settings, "int32_t[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]", "PicOrderCnt", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeH264ReferenceInfoFlags(const StdVideoDecodeH264ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.top_field_flag, settings, "uint32_t: 1", "top_field_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bottom_field_flag, settings, "uint32_t: 1", "bottom_field_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.used_for_long_term_reference, settings, "uint32_t: 1", "used_for_long_term_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.is_non_existing, settings, "uint32_t: 1", "is_non_existing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeH264ReferenceInfo(const StdVideoDecodeH264ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoDecodeH264ReferenceInfoFlags<Format>(object.flags, settings, "StdVideoDecodeH264ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.FrameNum, settings, "uint16_t", "FrameNum", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.reserved, settings, "uint16_t", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.PicOrderCnt, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE, settings, "int32_t[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]", "PicOrderCnt", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264WeightTableFlags(const StdVideoEncodeH264WeightTableFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.luma_weight_l0_flag, settings, "uint32_t", "luma_weight_l0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_weight_l0_flag, settings, "uint32_t", "chroma_weight_l0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.luma_weight_l1_flag, settings, "uint32_t", "luma_weight_l1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_weight_l1_flag, settings, "uint32_t", "chroma_weight_l1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264WeightTable(const StdVideoEncodeH264WeightTable& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeH264WeightTableFlags<Format>(object.flags, settings, "StdVideoEncodeH264WeightTableFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.luma_log2_weight_denom, settings, "uint8_t", "luma_log2_weight_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_log2_weight_denom, settings, "uint8_t", "chroma_log2_weight_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.luma_weight_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_weight_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.luma_offset_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_offset_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.chroma_weight_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_weight_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.chroma_offset_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_offset_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.luma_weight_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_weight_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.luma_offset_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_offset_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.chroma_weight_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_weight_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.chroma_offset_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_offset_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264SliceHeaderFlags(const StdVideoEncodeH264SliceHeaderFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.direct_spatial_mv_pred_flag, settings, "uint32_t: 1", "direct_spatial_mv_pred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ref_idx_active_override_flag, settings, "uint32_t: 1", "num_ref_idx_active_override_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264PictureInfoFlags(const StdVideoEncodeH264PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.IdrPicFlag, settings, "uint32_t: 1", "IdrPicFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.is_reference, settings, "uint32_t: 1", "is_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.no_output_of_prior_pics_flag, settings, "uint32_t: 1", "no_output_of_prior_pics_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.long_term_reference_flag, settings, "uint32_t: 1", "long_term_reference_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.adaptive_ref_pic_marking_mode_flag, settings, "uint32_t: 1", "adaptive_ref_pic_marking_mode_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 27", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264ReferenceInfoFlags(const StdVideoEncodeH264ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.used_for_long_term_reference, settings, "uint32_t: 1", "used_for_long_term_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 31", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264ReferenceListsInfoFlags(const StdVideoEncodeH264ReferenceListsInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.ref_pic_list_modification_flag_l0, settings, "uint32_t: 1", "ref_pic_list_modification_flag_l0", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.ref_pic_list_modification_flag_l1, settings, "uint32_t: 1", "ref_pic_list_modification_flag_l1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264RefListModEntry(const StdVideoEncodeH264RefListModEntry& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoH264ModificationOfPicNumsIdc<Format>(object.modification_of_pic_nums_idc, settings, "StdVideoH264ModificationOfPicNumsIdc", "modification_of_pic_nums_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.abs_diff_pic_num_minus1, settings, "uint16_t", "abs_diff_pic_num_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.long_term_pic_num, settings, "uint16_t", "long_term_pic_num", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264RefPicMarkingEntry(const StdVideoEncodeH264RefPicMarkingEntry& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoH264MemMgmtControlOp<Format>(object.memory_management_control_operation, settings, "StdVideoH264MemMgmtControlOp", "memory_management_control_operation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.difference_of_pic_nums_minus1, settings, "uint16_t", "difference_of_pic_nums_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.long_term_pic_num, settings, "uint16_t", "long_term_pic_num", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.long_term_frame_idx, settings, "uint16_t", "long_term_frame_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.max_long_term_frame_idx_plus1, settings, "uint16_t", "max_long_term_frame_idx_plus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264ReferenceListsInfo(const StdVideoEncodeH264ReferenceListsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeH264ReferenceListsInfoFlags<Format>(object.flags, settings, "StdVideoEncodeH264ReferenceListsInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ref_idx_l0_active_minus1, settings, "uint8_t", "num_ref_idx_l0_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ref_idx_l1_active_minus1, settings, "uint8_t", "num_ref_idx_l1_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.RefPicList0, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "RefPicList0", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.RefPicList1, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "RefPicList1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.refList0ModOpCount, settings, "uint8_t", "refList0ModOpCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.refList1ModOpCount, settings, "uint8_t", "refList1ModOpCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.refPicMarkingOpCount, settings, "uint8_t", "refPicMarkingOpCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.reserved1, 7, settings, "uint8_t[7]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRefList0ModOperations, object.refList0ModOpCount, settings, "const StdVideoEncodeH264RefListModEntry*", "pRefList0ModOperations", "const StdVideoEncodeH264RefListModEntry", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264RefListModEntry<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRefList1ModOperations, object.refList1ModOpCount, settings, "const StdVideoEncodeH264RefListModEntry*", "pRefList1ModOperations", "const StdVideoEncodeH264RefListModEntry", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264RefListModEntry<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRefPicMarkingOperations, object.refPicMarkingOpCount, settings, "const StdVideoEncodeH264RefPicMarkingEntry*", "pRefPicMarkingOperations", "const StdVideoEncodeH264RefPicMarkingEntry", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264RefPicMarkingEntry<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264PictureInfo(const StdVideoEncodeH264PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeH264PictureInfoFlags<Format>(object.flags, settings, "StdVideoEncodeH264PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.seq_parameter_set_id, settings, "uint8_t", "seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pic_parameter_set_id, settings, "uint8_t", "pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.idr_pic_id, settings, "uint16_t", "idr_pic_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264PictureType<Format>(object.primary_pic_type, settings, "StdVideoH264PictureType", "primary_pic_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_num, settings, "uint32_t", "frame_num", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.PicOrderCnt, settings, "int32_t", "PicOrderCnt", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.temporal_id, settings, "uint8_t", "temporal_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.reserved1, 3, settings, "uint8_t[3]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pRefLists, settings, "const StdVideoEncodeH264ReferenceListsInfo*", "pRefLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264ReferenceListsInfo<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264ReferenceInfo(const StdVideoEncodeH264ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeH264ReferenceInfoFlags<Format>(object.flags, settings, "StdVideoEncodeH264ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264PictureType<Format>(object.primary_pic_type, settings, "StdVideoH264PictureType", "primary_pic_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.FrameNum, settings, "uint32_t", "FrameNum", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.PicOrderCnt, settings, "int32_t", "PicOrderCnt", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.long_term_pic_num, settings, "uint16_t", "long_term_pic_num", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.long_term_frame_idx, settings, "uint16_t", "long_term_frame_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.temporal_id, settings, "uint8_t", "temporal_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH264SliceHeader(const StdVideoEncodeH264SliceHeader& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeH264SliceHeaderFlags<Format>(object.flags, settings, "StdVideoEncodeH264SliceHeaderFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.first_mb_in_slice, settings, "uint32_t", "first_mb_in_slice", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264SliceType<Format>(object.slice_type, settings, "StdVideoH264SliceType", "slice_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slice_alpha_c0_offset_div2, settings, "int8_t", "slice_alpha_c0_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slice_beta_offset_div2, settings, "int8_t", "slice_beta_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slice_qp_delta, settings, "int8_t", "slice_qp_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264CabacInitIdc<Format>(object.cabac_init_idc, settings, "StdVideoH264CabacInitIdc", "cabac_init_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264DisableDeblockingFilterIdc<Format>(object.disable_deblocking_filter_idc, settings, "StdVideoH264DisableDeblockingFilterIdc", "disable_deblocking_filter_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pWeightTable, settings, "const StdVideoEncodeH264WeightTable*", "pWeightTable", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264WeightTable<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265DecPicBufMgr(const StdVideoH265DecPicBufMgr& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_single_array<Format>(object.max_latency_increase_plus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "max_latency_increase_plus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.max_dec_pic_buffering_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, settings, "uint8_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "max_dec_pic_buffering_minus1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.max_num_reorder_pics, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, settings, "uint8_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "max_num_reorder_pics", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265SubLayerHrdParameters(const StdVideoH265SubLayerHrdParameters& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_single_array<Format>(object.bit_rate_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "bit_rate_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.cpb_size_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "cpb_size_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.cpb_size_du_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "cpb_size_du_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.bit_rate_du_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "bit_rate_du_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cbr_flag, settings, "uint32_t", "cbr_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265HrdFlags(const StdVideoH265HrdFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.nal_hrd_parameters_present_flag, settings, "uint32_t: 1", "nal_hrd_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vcl_hrd_parameters_present_flag, settings, "uint32_t: 1", "vcl_hrd_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sub_pic_hrd_params_present_flag, settings, "uint32_t: 1", "sub_pic_hrd_params_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sub_pic_cpb_params_in_pic_timing_sei_flag, settings, "uint32_t: 1", "sub_pic_cpb_params_in_pic_timing_sei_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.fixed_pic_rate_general_flag, settings, "uint32_t: 8", "fixed_pic_rate_general_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.fixed_pic_rate_within_cvs_flag, settings, "uint32_t: 8", "fixed_pic_rate_within_cvs_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.low_delay_hrd_flag, settings, "uint32_t: 8", "low_delay_hrd_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265HrdParameters(const StdVideoH265HrdParameters& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoH265HrdFlags<Format>(object.flags, settings, "StdVideoH265HrdFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tick_divisor_minus2, settings, "uint8_t", "tick_divisor_minus2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.du_cpb_removal_delay_increment_length_minus1, settings, "uint8_t", "du_cpb_removal_delay_increment_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dpb_output_delay_du_length_minus1, settings, "uint8_t", "dpb_output_delay_du_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bit_rate_scale, settings, "uint8_t", "bit_rate_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cpb_size_scale, settings, "uint8_t", "cpb_size_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cpb_size_du_scale, settings, "uint8_t", "cpb_size_du_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.initial_cpb_removal_delay_length_minus1, settings, "uint8_t", "initial_cpb_removal_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.au_cpb_removal_delay_length_minus1, settings, "uint8_t", "au_cpb_removal_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dpb_output_delay_length_minus1, settings, "uint8_t", "dpb_output_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.cpb_cnt_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, settings, "uint8_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "cpb_cnt_minus1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.elemental_duration_in_tc_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, settings, "uint16_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "elemental_duration_in_tc_minus1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint16_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.reserved, 3, settings, "uint16_t[3]", "reserved", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint16_t>);
    dump_separate_members<Format>(settings);
    if (object.flags.nal_hrd_parameters_present_flag == 1) {
        dump_pointer_array<Format>(object.pSubLayerHrdParametersNal, ApiDumpInstance::current().getIsInVps() ? ApiDumpInstance::current().getVpsMaxSubLayersMinus1() : ApiDumpInstance::current().getSpsMaxSubLayersMinus1(), settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersNal", "const StdVideoH265SubLayerHrdParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SubLayerHrdParameters<Format>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersNal", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersNal", indents + 2);
        }
    }
    dump_separate_members<Format>(settings);
    if (object.flags.vcl_hrd_parameters_present_flag == 1) {
        dump_pointer_array<Format>(object.pSubLayerHrdParametersVcl, ApiDumpInstance::current().getIsInVps() ? ApiDumpInstance::current().getVpsMaxSubLayersMinus1() : ApiDumpInstance::current().getSpsMaxSubLayersMinus1(), settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersVcl", "const StdVideoH265SubLayerHrdParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SubLayerHrdParameters<Format>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersVcl", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersVcl", indents + 2);
        }
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265VpsFlags(const StdVideoH265VpsFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.vps_temporal_id_nesting_flag, settings, "uint32_t: 1", "vps_temporal_id_nesting_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vps_sub_layer_ordering_info_present_flag, settings, "uint32_t: 1", "vps_sub_layer_ordering_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vps_timing_info_present_flag, settings, "uint32_t: 1", "vps_timing_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vps_poc_proportional_to_timing_flag, settings, "uint32_t: 1", "vps_poc_proportional_to_timing_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265ProfileTierLevelFlags(const StdVideoH265ProfileTierLevelFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.general_tier_flag, settings, "uint32_t: 1", "general_tier_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.general_progressive_source_flag, settings, "uint32_t: 1", "general_progressive_source_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.general_interlaced_source_flag, settings, "uint32_t: 1", "general_interlaced_source_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.general_non_packed_constraint_flag, settings, "uint32_t: 1", "general_non_packed_constraint_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.general_frame_only_constraint_flag, settings, "uint32_t: 1", "general_frame_only_constraint_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265ProfileTierLevel(const StdVideoH265ProfileTierLevel& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoH265ProfileTierLevelFlags<Format>(object.flags, settings, "StdVideoH265ProfileTierLevelFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265ProfileIdc<Format>(object.general_profile_idc, settings, "StdVideoH265ProfileIdc", "general_profile_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265LevelIdc<Format>(object.general_level_idc, settings, "StdVideoH265LevelIdc", "general_level_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265VideoParameterSet(const StdVideoH265VideoParameterSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    ApiDumpInstance::current().setVpsMaxSubLayersMinus1(object.vps_max_sub_layers_minus1);
    ApiDumpInstance::current().setIsInVps(true);
    dump_StdVideoH265VpsFlags<Format>(object.flags, settings, "StdVideoH265VpsFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vps_video_parameter_set_id, settings, "uint8_t", "vps_video_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vps_max_sub_layers_minus1, settings, "uint8_t", "vps_max_sub_layers_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vps_num_units_in_tick, settings, "uint32_t", "vps_num_units_in_tick", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vps_time_scale, settings, "uint32_t", "vps_time_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vps_num_ticks_poc_diff_one_minus1, settings, "uint32_t", "vps_num_ticks_poc_diff_one_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved3, settings, "uint32_t", "reserved3", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDecPicBufMgr, settings, "const StdVideoH265DecPicBufMgr*", "pDecPicBufMgr", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265DecPicBufMgr<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pHrdParameters, settings, "const StdVideoH265HrdParameters*", "pHrdParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265HrdParameters<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pProfileTierLevel, settings, "const StdVideoH265ProfileTierLevel*", "pProfileTierLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ProfileTierLevel<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265ScalingLists(const StdVideoH265ScalingLists& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_double_array<Format>(object.ScalingList4x4, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS]", "ScalingList4x4", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.ScalingList8x8, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS]", "ScalingList8x8", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.ScalingList16x16, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS]", "ScalingList16x16", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.ScalingList32x32, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS]", "ScalingList32x32", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.ScalingListDCCoef16x16, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS]", "ScalingListDCCoef16x16", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.ScalingListDCCoef32x32, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS]", "ScalingListDCCoef32x32", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265SpsVuiFlags(const StdVideoH265SpsVuiFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.aspect_ratio_info_present_flag, settings, "uint32_t: 1", "aspect_ratio_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.overscan_info_present_flag, settings, "uint32_t: 1", "overscan_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.overscan_appropriate_flag, settings, "uint32_t: 1", "overscan_appropriate_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.video_signal_type_present_flag, settings, "uint32_t: 1", "video_signal_type_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.video_full_range_flag, settings, "uint32_t: 1", "video_full_range_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colour_description_present_flag, settings, "uint32_t: 1", "colour_description_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_loc_info_present_flag, settings, "uint32_t: 1", "chroma_loc_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.neutral_chroma_indication_flag, settings, "uint32_t: 1", "neutral_chroma_indication_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.field_seq_flag, settings, "uint32_t: 1", "field_seq_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_field_info_present_flag, settings, "uint32_t: 1", "frame_field_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.default_display_window_flag, settings, "uint32_t: 1", "default_display_window_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vui_timing_info_present_flag, settings, "uint32_t: 1", "vui_timing_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vui_poc_proportional_to_timing_flag, settings, "uint32_t: 1", "vui_poc_proportional_to_timing_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vui_hrd_parameters_present_flag, settings, "uint32_t: 1", "vui_hrd_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bitstream_restriction_flag, settings, "uint32_t: 1", "bitstream_restriction_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tiles_fixed_structure_flag, settings, "uint32_t: 1", "tiles_fixed_structure_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.motion_vectors_over_pic_boundaries_flag, settings, "uint32_t: 1", "motion_vectors_over_pic_boundaries_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.restricted_ref_pic_lists_flag, settings, "uint32_t: 1", "restricted_ref_pic_lists_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265SequenceParameterSetVui(const StdVideoH265SequenceParameterSetVui& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoH265SpsVuiFlags<Format>(object.flags, settings, "StdVideoH265SpsVuiFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265AspectRatioIdc<Format>(object.aspect_ratio_idc, settings, "StdVideoH265AspectRatioIdc", "aspect_ratio_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.sar_width, settings, "uint16_t", "sar_width", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.sar_height, settings, "uint16_t", "sar_height", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.video_format, settings, "uint8_t", "video_format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colour_primaries, settings, "uint8_t", "colour_primaries", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.transfer_characteristics, settings, "uint8_t", "transfer_characteristics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.matrix_coeffs, settings, "uint8_t", "matrix_coeffs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_sample_loc_type_top_field, settings, "uint8_t", "chroma_sample_loc_type_top_field", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_sample_loc_type_bottom_field, settings, "uint8_t", "chroma_sample_loc_type_bottom_field", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.def_disp_win_left_offset, settings, "uint16_t", "def_disp_win_left_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.def_disp_win_right_offset, settings, "uint16_t", "def_disp_win_right_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.def_disp_win_top_offset, settings, "uint16_t", "def_disp_win_top_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.def_disp_win_bottom_offset, settings, "uint16_t", "def_disp_win_bottom_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vui_num_units_in_tick, settings, "uint32_t", "vui_num_units_in_tick", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vui_time_scale, settings, "uint32_t", "vui_time_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vui_num_ticks_poc_diff_one_minus1, settings, "uint32_t", "vui_num_ticks_poc_diff_one_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.min_spatial_segmentation_idc, settings, "uint16_t", "min_spatial_segmentation_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.reserved3, settings, "uint16_t", "reserved3", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.max_bytes_per_pic_denom, settings, "uint8_t", "max_bytes_per_pic_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.max_bits_per_min_cu_denom, settings, "uint8_t", "max_bits_per_min_cu_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_max_mv_length_horizontal, settings, "uint8_t", "log2_max_mv_length_horizontal", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_max_mv_length_vertical, settings, "uint8_t", "log2_max_mv_length_vertical", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pHrdParameters, settings, "const StdVideoH265HrdParameters*", "pHrdParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265HrdParameters<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265PredictorPaletteEntries(const StdVideoH265PredictorPaletteEntries& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_double_array<Format>(object.PredictorPaletteEntries, STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE, STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE, settings, "uint16_t[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE]", "PredictorPaletteEntries", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint16_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265SpsFlags(const StdVideoH265SpsFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.sps_temporal_id_nesting_flag, settings, "uint32_t: 1", "sps_temporal_id_nesting_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.separate_colour_plane_flag, settings, "uint32_t: 1", "separate_colour_plane_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.conformance_window_flag, settings, "uint32_t: 1", "conformance_window_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_sub_layer_ordering_info_present_flag, settings, "uint32_t: 1", "sps_sub_layer_ordering_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.scaling_list_enabled_flag, settings, "uint32_t: 1", "scaling_list_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_scaling_list_data_present_flag, settings, "uint32_t: 1", "sps_scaling_list_data_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.amp_enabled_flag, settings, "uint32_t: 1", "amp_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sample_adaptive_offset_enabled_flag, settings, "uint32_t: 1", "sample_adaptive_offset_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pcm_enabled_flag, settings, "uint32_t: 1", "pcm_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pcm_loop_filter_disabled_flag, settings, "uint32_t: 1", "pcm_loop_filter_disabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.long_term_ref_pics_present_flag, settings, "uint32_t: 1", "long_term_ref_pics_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_temporal_mvp_enabled_flag, settings, "uint32_t: 1", "sps_temporal_mvp_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.strong_intra_smoothing_enabled_flag, settings, "uint32_t: 1", "strong_intra_smoothing_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vui_parameters_present_flag, settings, "uint32_t: 1", "vui_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_extension_present_flag, settings, "uint32_t: 1", "sps_extension_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_range_extension_flag, settings, "uint32_t: 1", "sps_range_extension_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.transform_skip_rotation_enabled_flag, settings, "uint32_t: 1", "transform_skip_rotation_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.transform_skip_context_enabled_flag, settings, "uint32_t: 1", "transform_skip_context_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.implicit_rdpcm_enabled_flag, settings, "uint32_t: 1", "implicit_rdpcm_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.explicit_rdpcm_enabled_flag, settings, "uint32_t: 1", "explicit_rdpcm_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.extended_precision_processing_flag, settings, "uint32_t: 1", "extended_precision_processing_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.intra_smoothing_disabled_flag, settings, "uint32_t: 1", "intra_smoothing_disabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.high_precision_offsets_enabled_flag, settings, "uint32_t: 1", "high_precision_offsets_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.persistent_rice_adaptation_enabled_flag, settings, "uint32_t: 1", "persistent_rice_adaptation_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cabac_bypass_alignment_enabled_flag, settings, "uint32_t: 1", "cabac_bypass_alignment_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_scc_extension_flag, settings, "uint32_t: 1", "sps_scc_extension_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_curr_pic_ref_enabled_flag, settings, "uint32_t: 1", "sps_curr_pic_ref_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.palette_mode_enabled_flag, settings, "uint32_t: 1", "palette_mode_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_palette_predictor_initializers_present_flag, settings, "uint32_t: 1", "sps_palette_predictor_initializers_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.intra_boundary_filtering_disabled_flag, settings, "uint32_t: 1", "intra_boundary_filtering_disabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265ShortTermRefPicSetFlags(const StdVideoH265ShortTermRefPicSetFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.inter_ref_pic_set_prediction_flag, settings, "uint32_t: 1", "inter_ref_pic_set_prediction_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_rps_sign, settings, "uint32_t: 1", "delta_rps_sign", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265ShortTermRefPicSet(const StdVideoH265ShortTermRefPicSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoH265ShortTermRefPicSetFlags<Format>(object.flags, settings, "StdVideoH265ShortTermRefPicSetFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_idx_minus1, settings, "uint32_t", "delta_idx_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.use_delta_flag, settings, "uint16_t", "use_delta_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.abs_delta_rps_minus1, settings, "uint16_t", "abs_delta_rps_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.used_by_curr_pic_flag, settings, "uint16_t", "used_by_curr_pic_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.used_by_curr_pic_s0_flag, settings, "uint16_t", "used_by_curr_pic_s0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.used_by_curr_pic_s1_flag, settings, "uint16_t", "used_by_curr_pic_s1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.reserved1, settings, "uint16_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved3, settings, "uint8_t", "reserved3", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_negative_pics, settings, "uint8_t", "num_negative_pics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_positive_pics, settings, "uint8_t", "num_positive_pics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.delta_poc_s0_minus1, STD_VIDEO_H265_MAX_DPB_SIZE, settings, "uint16_t[STD_VIDEO_H265_MAX_DPB_SIZE]", "delta_poc_s0_minus1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint16_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.delta_poc_s1_minus1, STD_VIDEO_H265_MAX_DPB_SIZE, settings, "uint16_t[STD_VIDEO_H265_MAX_DPB_SIZE]", "delta_poc_s1_minus1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint16_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265LongTermRefPicsSps(const StdVideoH265LongTermRefPicsSps& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.used_by_curr_pic_lt_sps_flag, settings, "uint32_t", "used_by_curr_pic_lt_sps_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.lt_ref_pic_poc_lsb_sps, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS, settings, "uint32_t[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]", "lt_ref_pic_poc_lsb_sps", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265SequenceParameterSet(const StdVideoH265SequenceParameterSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    ApiDumpInstance::current().setSpsMaxSubLayersMinus1(object.sps_max_sub_layers_minus1);
    ApiDumpInstance::current().setIsInVps(false);
    dump_StdVideoH265SpsFlags<Format>(object.flags, settings, "StdVideoH265SpsFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265ChromaFormatIdc<Format>(object.chroma_format_idc, settings, "StdVideoH265ChromaFormatIdc", "chroma_format_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pic_width_in_luma_samples, settings, "uint32_t", "pic_width_in_luma_samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pic_height_in_luma_samples, settings, "uint32_t", "pic_height_in_luma_samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_video_parameter_set_id, settings, "uint8_t", "sps_video_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_max_sub_layers_minus1, settings, "uint8_t", "sps_max_sub_layers_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_seq_parameter_set_id, settings, "uint8_t", "sps_seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bit_depth_luma_minus8, settings, "uint8_t", "bit_depth_luma_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bit_depth_chroma_minus8, settings, "uint8_t", "bit_depth_chroma_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_max_pic_order_cnt_lsb_minus4, settings, "uint8_t", "log2_max_pic_order_cnt_lsb_minus4", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_min_luma_coding_block_size_minus3, settings, "uint8_t", "log2_min_luma_coding_block_size_minus3", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_diff_max_min_luma_coding_block_size, settings, "uint8_t", "log2_diff_max_min_luma_coding_block_size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_min_luma_transform_block_size_minus2, settings, "uint8_t", "log2_min_luma_transform_block_size_minus2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_diff_max_min_luma_transform_block_size, settings, "uint8_t", "log2_diff_max_min_luma_transform_block_size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.max_transform_hierarchy_depth_inter, settings, "uint8_t", "max_transform_hierarchy_depth_inter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.max_transform_hierarchy_depth_intra, settings, "uint8_t", "max_transform_hierarchy_depth_intra", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_short_term_ref_pic_sets, settings, "uint8_t", "num_short_term_ref_pic_sets", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_long_term_ref_pics_sps, settings, "uint8_t", "num_long_term_ref_pics_sps", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pcm_sample_bit_depth_luma_minus1, settings, "uint8_t", "pcm_sample_bit_depth_luma_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pcm_sample_bit_depth_chroma_minus1, settings, "uint8_t", "pcm_sample_bit_depth_chroma_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_min_pcm_luma_coding_block_size_minus3, settings, "uint8_t", "log2_min_pcm_luma_coding_block_size_minus3", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_diff_max_min_pcm_luma_coding_block_size, settings, "uint8_t", "log2_diff_max_min_pcm_luma_coding_block_size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.palette_max_size, settings, "uint8_t", "palette_max_size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_palette_max_predictor_size, settings, "uint8_t", "delta_palette_max_predictor_size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.motion_vector_resolution_control_idc, settings, "uint8_t", "motion_vector_resolution_control_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_num_palette_predictor_initializers_minus1, settings, "uint8_t", "sps_num_palette_predictor_initializers_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.conf_win_left_offset, settings, "uint32_t", "conf_win_left_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.conf_win_right_offset, settings, "uint32_t", "conf_win_right_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.conf_win_top_offset, settings, "uint32_t", "conf_win_top_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.conf_win_bottom_offset, settings, "uint32_t", "conf_win_bottom_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pProfileTierLevel, settings, "const StdVideoH265ProfileTierLevel*", "pProfileTierLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ProfileTierLevel<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDecPicBufMgr, settings, "const StdVideoH265DecPicBufMgr*", "pDecPicBufMgr", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265DecPicBufMgr<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pScalingLists, settings, "const StdVideoH265ScalingLists*", "pScalingLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ScalingLists<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pShortTermRefPicSet, object.num_short_term_ref_pic_sets, settings, "const StdVideoH265ShortTermRefPicSet*", "pShortTermRefPicSet", "const StdVideoH265ShortTermRefPicSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ShortTermRefPicSet<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pLongTermRefPicsSps, settings, "const StdVideoH265LongTermRefPicsSps*", "pLongTermRefPicsSps", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265LongTermRefPicsSps<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSequenceParameterSetVui, settings, "const StdVideoH265SequenceParameterSetVui*", "pSequenceParameterSetVui", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSetVui<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pPredictorPaletteEntries, settings, "const StdVideoH265PredictorPaletteEntries*", "pPredictorPaletteEntries", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PredictorPaletteEntries<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265PpsFlags(const StdVideoH265PpsFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.dependent_slice_segments_enabled_flag, settings, "uint32_t: 1", "dependent_slice_segments_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.output_flag_present_flag, settings, "uint32_t: 1", "output_flag_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sign_data_hiding_enabled_flag, settings, "uint32_t: 1", "sign_data_hiding_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cabac_init_present_flag, settings, "uint32_t: 1", "cabac_init_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.constrained_intra_pred_flag, settings, "uint32_t: 1", "constrained_intra_pred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.transform_skip_enabled_flag, settings, "uint32_t: 1", "transform_skip_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cu_qp_delta_enabled_flag, settings, "uint32_t: 1", "cu_qp_delta_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_slice_chroma_qp_offsets_present_flag, settings, "uint32_t: 1", "pps_slice_chroma_qp_offsets_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.weighted_pred_flag, settings, "uint32_t: 1", "weighted_pred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.weighted_bipred_flag, settings, "uint32_t: 1", "weighted_bipred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.transquant_bypass_enabled_flag, settings, "uint32_t: 1", "transquant_bypass_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tiles_enabled_flag, settings, "uint32_t: 1", "tiles_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.entropy_coding_sync_enabled_flag, settings, "uint32_t: 1", "entropy_coding_sync_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.uniform_spacing_flag, settings, "uint32_t: 1", "uniform_spacing_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.loop_filter_across_tiles_enabled_flag, settings, "uint32_t: 1", "loop_filter_across_tiles_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_loop_filter_across_slices_enabled_flag, settings, "uint32_t: 1", "pps_loop_filter_across_slices_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deblocking_filter_control_present_flag, settings, "uint32_t: 1", "deblocking_filter_control_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deblocking_filter_override_enabled_flag, settings, "uint32_t: 1", "deblocking_filter_override_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_deblocking_filter_disabled_flag, settings, "uint32_t: 1", "pps_deblocking_filter_disabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_scaling_list_data_present_flag, settings, "uint32_t: 1", "pps_scaling_list_data_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.lists_modification_present_flag, settings, "uint32_t: 1", "lists_modification_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.slice_segment_header_extension_present_flag, settings, "uint32_t: 1", "slice_segment_header_extension_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_extension_present_flag, settings, "uint32_t: 1", "pps_extension_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cross_component_prediction_enabled_flag, settings, "uint32_t: 1", "cross_component_prediction_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_qp_offset_list_enabled_flag, settings, "uint32_t: 1", "chroma_qp_offset_list_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_curr_pic_ref_enabled_flag, settings, "uint32_t: 1", "pps_curr_pic_ref_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.residual_adaptive_colour_transform_enabled_flag, settings, "uint32_t: 1", "residual_adaptive_colour_transform_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_slice_act_qp_offsets_present_flag, settings, "uint32_t: 1", "pps_slice_act_qp_offsets_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_palette_predictor_initializers_present_flag, settings, "uint32_t: 1", "pps_palette_predictor_initializers_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.monochrome_palette_flag, settings, "uint32_t: 1", "monochrome_palette_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_range_extension_flag, settings, "uint32_t: 1", "pps_range_extension_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoH265PictureParameterSet(const StdVideoH265PictureParameterSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoH265PpsFlags<Format>(object.flags, settings, "StdVideoH265PpsFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_pic_parameter_set_id, settings, "uint8_t", "pps_pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_seq_parameter_set_id, settings, "uint8_t", "pps_seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_video_parameter_set_id, settings, "uint8_t", "sps_video_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_extra_slice_header_bits, settings, "uint8_t", "num_extra_slice_header_bits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ref_idx_l0_default_active_minus1, settings, "uint8_t", "num_ref_idx_l0_default_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ref_idx_l1_default_active_minus1, settings, "uint8_t", "num_ref_idx_l1_default_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.init_qp_minus26, settings, "int8_t", "init_qp_minus26", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.diff_cu_qp_delta_depth, settings, "uint8_t", "diff_cu_qp_delta_depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.pps_cb_qp_offset, settings, "int8_t", "pps_cb_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.pps_cr_qp_offset, settings, "int8_t", "pps_cr_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.pps_beta_offset_div2, settings, "int8_t", "pps_beta_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.pps_tc_offset_div2, settings, "int8_t", "pps_tc_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_parallel_merge_level_minus2, settings, "uint8_t", "log2_parallel_merge_level_minus2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_max_transform_skip_block_size_minus2, settings, "uint8_t", "log2_max_transform_skip_block_size_minus2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.diff_cu_chroma_qp_offset_depth, settings, "uint8_t", "diff_cu_chroma_qp_offset_depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_qp_offset_list_len_minus1, settings, "uint8_t", "chroma_qp_offset_list_len_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.cb_qp_offset_list, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE, settings, "int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]", "cb_qp_offset_list", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.cr_qp_offset_list, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE, settings, "int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]", "cr_qp_offset_list", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_sao_offset_scale_luma, settings, "uint8_t", "log2_sao_offset_scale_luma", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.log2_sao_offset_scale_chroma, settings, "uint8_t", "log2_sao_offset_scale_chroma", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.pps_act_y_qp_offset_plus5, settings, "int8_t", "pps_act_y_qp_offset_plus5", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.pps_act_cb_qp_offset_plus5, settings, "int8_t", "pps_act_cb_qp_offset_plus5", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.pps_act_cr_qp_offset_plus3, settings, "int8_t", "pps_act_cr_qp_offset_plus3", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_num_palette_predictor_initializers, settings, "uint8_t", "pps_num_palette_predictor_initializers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.luma_bit_depth_entry_minus8, settings, "uint8_t", "luma_bit_depth_entry_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.chroma_bit_depth_entry_minus8, settings, "uint8_t", "chroma_bit_depth_entry_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_tile_columns_minus1, settings, "uint8_t", "num_tile_columns_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_tile_rows_minus1, settings, "uint8_t", "num_tile_rows_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.column_width_minus1, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE, settings, "uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]", "column_width_minus1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint16_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.row_height_minus1, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE, settings, "uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]", "row_height_minus1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint16_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved3, settings, "uint32_t", "reserved3", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pScalingLists, settings, "const StdVideoH265ScalingLists*", "pScalingLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ScalingLists<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pPredictorPaletteEntries, settings, "const StdVideoH265PredictorPaletteEntries*", "pPredictorPaletteEntries", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PredictorPaletteEntries<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeH265PictureInfoFlags(const StdVideoDecodeH265PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.IrapPicFlag, settings, "uint32_t: 1", "IrapPicFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.IdrPicFlag, settings, "uint32_t: 1", "IdrPicFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.IsReference, settings, "uint32_t: 1", "IsReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.short_term_ref_pic_set_sps_flag, settings, "uint32_t: 1", "short_term_ref_pic_set_sps_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeH265PictureInfo(const StdVideoDecodeH265PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoDecodeH265PictureInfoFlags<Format>(object.flags, settings, "StdVideoDecodeH265PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_video_parameter_set_id, settings, "uint8_t", "sps_video_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_seq_parameter_set_id, settings, "uint8_t", "pps_seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_pic_parameter_set_id, settings, "uint8_t", "pps_pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.NumDeltaPocsOfRefRpsIdx, settings, "uint8_t", "NumDeltaPocsOfRefRpsIdx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.PicOrderCntVal, settings, "int32_t", "PicOrderCntVal", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.NumBitsForSTRefPicSetInSlice, settings, "uint16_t", "NumBitsForSTRefPicSetInSlice", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.reserved, settings, "uint16_t", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.RefPicSetStCurrBefore, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE, settings, "uint8_t[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]", "RefPicSetStCurrBefore", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.RefPicSetStCurrAfter, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE, settings, "uint8_t[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]", "RefPicSetStCurrAfter", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.RefPicSetLtCurr, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE, settings, "uint8_t[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]", "RefPicSetLtCurr", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeH265ReferenceInfoFlags(const StdVideoDecodeH265ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.used_for_long_term_reference, settings, "uint32_t: 1", "used_for_long_term_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.unused_for_reference, settings, "uint32_t: 1", "unused_for_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeH265ReferenceInfo(const StdVideoDecodeH265ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoDecodeH265ReferenceInfoFlags<Format>(object.flags, settings, "StdVideoDecodeH265ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.PicOrderCntVal, settings, "int32_t", "PicOrderCntVal", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH265WeightTableFlags(const StdVideoEncodeH265WeightTableFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint16_t>(object.luma_weight_l0_flag, settings, "uint16_t", "luma_weight_l0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.chroma_weight_l0_flag, settings, "uint16_t", "chroma_weight_l0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.luma_weight_l1_flag, settings, "uint16_t", "luma_weight_l1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.chroma_weight_l1_flag, settings, "uint16_t", "chroma_weight_l1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH265WeightTable(const StdVideoEncodeH265WeightTable& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeH265WeightTableFlags<Format>(object.flags, settings, "StdVideoEncodeH265WeightTableFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.luma_log2_weight_denom, settings, "uint8_t", "luma_log2_weight_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.delta_chroma_log2_weight_denom, settings, "int8_t", "delta_chroma_log2_weight_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.delta_luma_weight_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "delta_luma_weight_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.luma_offset_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "luma_offset_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.delta_chroma_weight_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_weight_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.delta_chroma_offset_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_offset_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.delta_luma_weight_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "delta_luma_weight_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.luma_offset_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "luma_offset_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.delta_chroma_weight_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_weight_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.delta_chroma_offset_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_offset_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH265SliceSegmentHeaderFlags(const StdVideoEncodeH265SliceSegmentHeaderFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.first_slice_segment_in_pic_flag, settings, "uint32_t: 1", "first_slice_segment_in_pic_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dependent_slice_segment_flag, settings, "uint32_t: 1", "dependent_slice_segment_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.slice_sao_luma_flag, settings, "uint32_t: 1", "slice_sao_luma_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.slice_sao_chroma_flag, settings, "uint32_t: 1", "slice_sao_chroma_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ref_idx_active_override_flag, settings, "uint32_t: 1", "num_ref_idx_active_override_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.mvd_l1_zero_flag, settings, "uint32_t: 1", "mvd_l1_zero_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cabac_init_flag, settings, "uint32_t: 1", "cabac_init_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cu_chroma_qp_offset_enabled_flag, settings, "uint32_t: 1", "cu_chroma_qp_offset_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deblocking_filter_override_flag, settings, "uint32_t: 1", "deblocking_filter_override_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.slice_deblocking_filter_disabled_flag, settings, "uint32_t: 1", "slice_deblocking_filter_disabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.collocated_from_l0_flag, settings, "uint32_t: 1", "collocated_from_l0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.slice_loop_filter_across_slices_enabled_flag, settings, "uint32_t: 1", "slice_loop_filter_across_slices_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 20", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH265SliceSegmentHeader(const StdVideoEncodeH265SliceSegmentHeader& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeH265SliceSegmentHeaderFlags<Format>(object.flags, settings, "StdVideoEncodeH265SliceSegmentHeaderFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265SliceType<Format>(object.slice_type, settings, "StdVideoH265SliceType", "slice_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.slice_segment_address, settings, "uint32_t", "slice_segment_address", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.collocated_ref_idx, settings, "uint8_t", "collocated_ref_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.MaxNumMergeCand, settings, "uint8_t", "MaxNumMergeCand", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slice_cb_qp_offset, settings, "int8_t", "slice_cb_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slice_cr_qp_offset, settings, "int8_t", "slice_cr_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slice_beta_offset_div2, settings, "int8_t", "slice_beta_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slice_tc_offset_div2, settings, "int8_t", "slice_tc_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slice_act_y_qp_offset, settings, "int8_t", "slice_act_y_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slice_act_cb_qp_offset, settings, "int8_t", "slice_act_cb_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slice_act_cr_qp_offset, settings, "int8_t", "slice_act_cr_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slice_qp_delta, settings, "int8_t", "slice_qp_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.reserved1, settings, "uint16_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pWeightTable, settings, "const StdVideoEncodeH265WeightTable*", "pWeightTable", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265WeightTable<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH265ReferenceListsInfoFlags(const StdVideoEncodeH265ReferenceListsInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.ref_pic_list_modification_flag_l0, settings, "uint32_t: 1", "ref_pic_list_modification_flag_l0", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.ref_pic_list_modification_flag_l1, settings, "uint32_t: 1", "ref_pic_list_modification_flag_l1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH265ReferenceListsInfo(const StdVideoEncodeH265ReferenceListsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeH265ReferenceListsInfoFlags<Format>(object.flags, settings, "StdVideoEncodeH265ReferenceListsInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ref_idx_l0_active_minus1, settings, "uint8_t", "num_ref_idx_l0_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ref_idx_l1_active_minus1, settings, "uint8_t", "num_ref_idx_l1_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.RefPicList0, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "RefPicList0", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.RefPicList1, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "RefPicList1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.list_entry_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "list_entry_l0", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.list_entry_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "list_entry_l1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH265PictureInfoFlags(const StdVideoEncodeH265PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.is_reference, settings, "uint32_t: 1", "is_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.IrapPicFlag, settings, "uint32_t: 1", "IrapPicFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.used_for_long_term_reference, settings, "uint32_t: 1", "used_for_long_term_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.discardable_flag, settings, "uint32_t: 1", "discardable_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cross_layer_bla_flag, settings, "uint32_t: 1", "cross_layer_bla_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pic_output_flag, settings, "uint32_t: 1", "pic_output_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.no_output_of_prior_pics_flag, settings, "uint32_t: 1", "no_output_of_prior_pics_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.short_term_ref_pic_set_sps_flag, settings, "uint32_t: 1", "short_term_ref_pic_set_sps_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.slice_temporal_mvp_enabled_flag, settings, "uint32_t: 1", "slice_temporal_mvp_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 23", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH265LongTermRefPics(const StdVideoEncodeH265LongTermRefPics& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.num_long_term_sps, settings, "uint8_t", "num_long_term_sps", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_long_term_pics, settings, "uint8_t", "num_long_term_pics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.lt_idx_sps, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS, settings, "uint8_t[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]", "lt_idx_sps", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.poc_lsb_lt, STD_VIDEO_H265_MAX_LONG_TERM_PICS, settings, "uint8_t[STD_VIDEO_H265_MAX_LONG_TERM_PICS]", "poc_lsb_lt", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.used_by_curr_pic_lt_flag, settings, "uint16_t", "used_by_curr_pic_lt_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.delta_poc_msb_present_flag, STD_VIDEO_H265_MAX_DELTA_POC, settings, "uint8_t[STD_VIDEO_H265_MAX_DELTA_POC]", "delta_poc_msb_present_flag", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.delta_poc_msb_cycle_lt, STD_VIDEO_H265_MAX_DELTA_POC, settings, "uint8_t[STD_VIDEO_H265_MAX_DELTA_POC]", "delta_poc_msb_cycle_lt", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH265PictureInfo(const StdVideoEncodeH265PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeH265PictureInfoFlags<Format>(object.flags, settings, "StdVideoEncodeH265PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265PictureType<Format>(object.pic_type, settings, "StdVideoH265PictureType", "pic_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sps_video_parameter_set_id, settings, "uint8_t", "sps_video_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_seq_parameter_set_id, settings, "uint8_t", "pps_seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pps_pic_parameter_set_id, settings, "uint8_t", "pps_pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.short_term_ref_pic_set_idx, settings, "uint8_t", "short_term_ref_pic_set_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.PicOrderCntVal, settings, "int32_t", "PicOrderCntVal", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.TemporalId, settings, "uint8_t", "TemporalId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.reserved1, 7, settings, "uint8_t[7]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pRefLists, settings, "const StdVideoEncodeH265ReferenceListsInfo*", "pRefLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265ReferenceListsInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pShortTermRefPicSet, settings, "const StdVideoH265ShortTermRefPicSet*", "pShortTermRefPicSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ShortTermRefPicSet<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pLongTermRefPics, settings, "const StdVideoEncodeH265LongTermRefPics*", "pLongTermRefPics", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265LongTermRefPics<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH265ReferenceInfoFlags(const StdVideoEncodeH265ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.used_for_long_term_reference, settings, "uint32_t: 1", "used_for_long_term_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.unused_for_reference, settings, "uint32_t: 1", "unused_for_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeH265ReferenceInfo(const StdVideoEncodeH265ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeH265ReferenceInfoFlags<Format>(object.flags, settings, "StdVideoEncodeH265ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265PictureType<Format>(object.pic_type, settings, "StdVideoH265PictureType", "pic_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.PicOrderCntVal, settings, "int32_t", "PicOrderCntVal", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.TemporalId, settings, "uint8_t", "TemporalId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1ColorConfigFlags(const StdVideoAV1ColorConfigFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.mono_chrome, settings, "uint32_t: 1", "mono_chrome", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.color_range, settings, "uint32_t: 1", "color_range", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.separate_uv_delta_q, settings, "uint32_t: 1", "separate_uv_delta_q", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.color_description_present_flag, settings, "uint32_t: 1", "color_description_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 28", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1ColorConfig(const StdVideoAV1ColorConfig& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoAV1ColorConfigFlags<Format>(object.flags, settings, "StdVideoAV1ColorConfigFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.BitDepth, settings, "uint8_t", "BitDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subsampling_x, settings, "uint8_t", "subsampling_x", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subsampling_y, settings, "uint8_t", "subsampling_y", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1ColorPrimaries<Format>(object.color_primaries, settings, "StdVideoAV1ColorPrimaries", "color_primaries", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1TransferCharacteristics<Format>(object.transfer_characteristics, settings, "StdVideoAV1TransferCharacteristics", "transfer_characteristics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1MatrixCoefficients<Format>(object.matrix_coefficients, settings, "StdVideoAV1MatrixCoefficients", "matrix_coefficients", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1ChromaSamplePosition<Format>(object.chroma_sample_position, settings, "StdVideoAV1ChromaSamplePosition", "chroma_sample_position", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1TimingInfoFlags(const StdVideoAV1TimingInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.equal_picture_interval, settings, "uint32_t: 1", "equal_picture_interval", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 31", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1TimingInfo(const StdVideoAV1TimingInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoAV1TimingInfoFlags<Format>(object.flags, settings, "StdVideoAV1TimingInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_units_in_display_tick, settings, "uint32_t", "num_units_in_display_tick", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.time_scale, settings, "uint32_t", "time_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_ticks_per_picture_minus_1, settings, "uint32_t", "num_ticks_per_picture_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1LoopFilterFlags(const StdVideoAV1LoopFilterFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.loop_filter_delta_enabled, settings, "uint32_t: 1", "loop_filter_delta_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.loop_filter_delta_update, settings, "uint32_t: 1", "loop_filter_delta_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1LoopFilter(const StdVideoAV1LoopFilter& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoAV1LoopFilterFlags<Format>(object.flags, settings, "StdVideoAV1LoopFilterFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.loop_filter_level, STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS, settings, "uint8_t[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS]", "loop_filter_level", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.loop_filter_sharpness, settings, "uint8_t", "loop_filter_sharpness", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.update_ref_delta, settings, "uint8_t", "update_ref_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.loop_filter_ref_deltas, STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME, settings, "int8_t[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME]", "loop_filter_ref_deltas", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.update_mode_delta, settings, "uint8_t", "update_mode_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.loop_filter_mode_deltas, STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS, settings, "int8_t[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS]", "loop_filter_mode_deltas", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1QuantizationFlags(const StdVideoAV1QuantizationFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.using_qmatrix, settings, "uint32_t: 1", "using_qmatrix", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.diff_uv_delta, settings, "uint32_t: 1", "diff_uv_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1Quantization(const StdVideoAV1Quantization& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoAV1QuantizationFlags<Format>(object.flags, settings, "StdVideoAV1QuantizationFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.base_q_idx, settings, "uint8_t", "base_q_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.DeltaQYDc, settings, "int8_t", "DeltaQYDc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.DeltaQUDc, settings, "int8_t", "DeltaQUDc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.DeltaQUAc, settings, "int8_t", "DeltaQUAc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.DeltaQVDc, settings, "int8_t", "DeltaQVDc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.DeltaQVAc, settings, "int8_t", "DeltaQVAc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.qm_y, settings, "uint8_t", "qm_y", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.qm_u, settings, "uint8_t", "qm_u", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.qm_v, settings, "uint8_t", "qm_v", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1Segmentation(const StdVideoAV1Segmentation& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_single_array<Format>(object.FeatureEnabled, STD_VIDEO_AV1_MAX_SEGMENTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_SEGMENTS]", "FeatureEnabled", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.FeatureData, STD_VIDEO_AV1_MAX_SEGMENTS, STD_VIDEO_AV1_SEG_LVL_MAX, settings, "int16_t[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX]", "FeatureData", "int16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int16_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1TileInfoFlags(const StdVideoAV1TileInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.uniform_tile_spacing_flag, settings, "uint32_t: 1", "uniform_tile_spacing_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 31", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1TileInfo(const StdVideoAV1TileInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoAV1TileInfoFlags<Format>(object.flags, settings, "StdVideoAV1TileInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.TileCols, settings, "uint8_t", "TileCols", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.TileRows, settings, "uint8_t", "TileRows", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.context_update_tile_id, settings, "uint16_t", "context_update_tile_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tile_size_bytes_minus_1, settings, "uint8_t", "tile_size_bytes_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.reserved1, 7, settings, "uint8_t[7]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pMiColStarts, object.TileCols, settings, "const uint16_t*", "pMiColStarts", "const uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint16_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pMiRowStarts, object.TileRows, settings, "const uint16_t*", "pMiRowStarts", "const uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint16_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pWidthInSbsMinus1, object.TileCols, settings, "const uint16_t*", "pWidthInSbsMinus1", "const uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint16_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pHeightInSbsMinus1, object.TileRows, settings, "const uint16_t*", "pHeightInSbsMinus1", "const uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint16_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1CDEF(const StdVideoAV1CDEF& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.cdef_damping_minus_3, settings, "uint8_t", "cdef_damping_minus_3", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cdef_bits, settings, "uint8_t", "cdef_bits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.cdef_y_pri_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, settings, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_y_pri_strength", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.cdef_y_sec_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, settings, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_y_sec_strength", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.cdef_uv_pri_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, settings, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_uv_pri_strength", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.cdef_uv_sec_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, settings, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_uv_sec_strength", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1LoopRestoration(const StdVideoAV1LoopRestoration& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_single_array<Format>(object.FrameRestorationType, STD_VIDEO_AV1_MAX_NUM_PLANES, settings, "StdVideoAV1FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES]", "FrameRestorationType", "StdVideoAV1FrameRestorationType", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1FrameRestorationType<Format>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.LoopRestorationSize, STD_VIDEO_AV1_MAX_NUM_PLANES, settings, "uint16_t[STD_VIDEO_AV1_MAX_NUM_PLANES]", "LoopRestorationSize", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint16_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1GlobalMotion(const StdVideoAV1GlobalMotion& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_single_array<Format>(object.GmType, STD_VIDEO_AV1_NUM_REF_FRAMES, settings, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "GmType", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.gm_params, STD_VIDEO_AV1_NUM_REF_FRAMES, STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS, settings, "int32_t[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS]", "gm_params", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1FilmGrainFlags(const StdVideoAV1FilmGrainFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.chroma_scaling_from_luma, settings, "uint32_t: 1", "chroma_scaling_from_luma", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.overlap_flag, settings, "uint32_t: 1", "overlap_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.clip_to_restricted_range, settings, "uint32_t: 1", "clip_to_restricted_range", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.update_grain, settings, "uint32_t: 1", "update_grain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 28", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1FilmGrain(const StdVideoAV1FilmGrain& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoAV1FilmGrainFlags<Format>(object.flags, settings, "StdVideoAV1FilmGrainFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.grain_scaling_minus_8, settings, "uint8_t", "grain_scaling_minus_8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.ar_coeff_lag, settings, "uint8_t", "ar_coeff_lag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.ar_coeff_shift_minus_6, settings, "uint8_t", "ar_coeff_shift_minus_6", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.grain_scale_shift, settings, "uint8_t", "grain_scale_shift", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.grain_seed, settings, "uint16_t", "grain_seed", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.film_grain_params_ref_idx, settings, "uint8_t", "film_grain_params_ref_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_y_points, settings, "uint8_t", "num_y_points", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.point_y_value, STD_VIDEO_AV1_MAX_NUM_Y_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]", "point_y_value", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.point_y_scaling, STD_VIDEO_AV1_MAX_NUM_Y_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]", "point_y_scaling", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_cb_points, settings, "uint8_t", "num_cb_points", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.point_cb_value, STD_VIDEO_AV1_MAX_NUM_CB_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]", "point_cb_value", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.point_cb_scaling, STD_VIDEO_AV1_MAX_NUM_CB_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]", "point_cb_scaling", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_cr_points, settings, "uint8_t", "num_cr_points", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.point_cr_value, STD_VIDEO_AV1_MAX_NUM_CR_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]", "point_cr_value", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.point_cr_scaling, STD_VIDEO_AV1_MAX_NUM_CR_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]", "point_cr_scaling", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.ar_coeffs_y_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_LUMA, settings, "int8_t[STD_VIDEO_AV1_MAX_NUM_POS_LUMA]", "ar_coeffs_y_plus_128", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.ar_coeffs_cb_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA, settings, "int8_t[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]", "ar_coeffs_cb_plus_128", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.ar_coeffs_cr_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA, settings, "int8_t[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]", "ar_coeffs_cr_plus_128", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cb_mult, settings, "uint8_t", "cb_mult", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cb_luma_mult, settings, "uint8_t", "cb_luma_mult", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.cb_offset, settings, "uint16_t", "cb_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cr_mult, settings, "uint8_t", "cr_mult", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cr_luma_mult, settings, "uint8_t", "cr_luma_mult", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.cr_offset, settings, "uint16_t", "cr_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1SequenceHeaderFlags(const StdVideoAV1SequenceHeaderFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.still_picture, settings, "uint32_t: 1", "still_picture", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reduced_still_picture_header, settings, "uint32_t: 1", "reduced_still_picture_header", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.use_128x128_superblock, settings, "uint32_t: 1", "use_128x128_superblock", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_filter_intra, settings, "uint32_t: 1", "enable_filter_intra", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_intra_edge_filter, settings, "uint32_t: 1", "enable_intra_edge_filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_interintra_compound, settings, "uint32_t: 1", "enable_interintra_compound", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_masked_compound, settings, "uint32_t: 1", "enable_masked_compound", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_warped_motion, settings, "uint32_t: 1", "enable_warped_motion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_dual_filter, settings, "uint32_t: 1", "enable_dual_filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_order_hint, settings, "uint32_t: 1", "enable_order_hint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_jnt_comp, settings, "uint32_t: 1", "enable_jnt_comp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_ref_frame_mvs, settings, "uint32_t: 1", "enable_ref_frame_mvs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_id_numbers_present_flag, settings, "uint32_t: 1", "frame_id_numbers_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_superres, settings, "uint32_t: 1", "enable_superres", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_cdef, settings, "uint32_t: 1", "enable_cdef", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enable_restoration, settings, "uint32_t: 1", "enable_restoration", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.film_grain_params_present, settings, "uint32_t: 1", "film_grain_params_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.timing_info_present_flag, settings, "uint32_t: 1", "timing_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.initial_display_delay_present_flag, settings, "uint32_t: 1", "initial_display_delay_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 13", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoAV1SequenceHeader(const StdVideoAV1SequenceHeader& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoAV1SequenceHeaderFlags<Format>(object.flags, settings, "StdVideoAV1SequenceHeaderFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1Profile<Format>(object.seq_profile, settings, "StdVideoAV1Profile", "seq_profile", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_width_bits_minus_1, settings, "uint8_t", "frame_width_bits_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_height_bits_minus_1, settings, "uint8_t", "frame_height_bits_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.max_frame_width_minus_1, settings, "uint16_t", "max_frame_width_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.max_frame_height_minus_1, settings, "uint16_t", "max_frame_height_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_frame_id_length_minus_2, settings, "uint8_t", "delta_frame_id_length_minus_2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.additional_frame_id_length_minus_1, settings, "uint8_t", "additional_frame_id_length_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.order_hint_bits_minus_1, settings, "uint8_t", "order_hint_bits_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.seq_force_integer_mv, settings, "uint8_t", "seq_force_integer_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.seq_force_screen_content_tools, settings, "uint8_t", "seq_force_screen_content_tools", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.reserved1, 5, settings, "uint8_t[5]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pColorConfig, settings, "const StdVideoAV1ColorConfig*", "pColorConfig", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1ColorConfig<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pTimingInfo, settings, "const StdVideoAV1TimingInfo*", "pTimingInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1TimingInfo<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeAV1PictureInfoFlags(const StdVideoDecodeAV1PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.error_resilient_mode, settings, "uint32_t: 1", "error_resilient_mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.disable_cdf_update, settings, "uint32_t: 1", "disable_cdf_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.use_superres, settings, "uint32_t: 1", "use_superres", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.render_and_frame_size_different, settings, "uint32_t: 1", "render_and_frame_size_different", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.allow_screen_content_tools, settings, "uint32_t: 1", "allow_screen_content_tools", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.is_filter_switchable, settings, "uint32_t: 1", "is_filter_switchable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.force_integer_mv, settings, "uint32_t: 1", "force_integer_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_size_override_flag, settings, "uint32_t: 1", "frame_size_override_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.buffer_removal_time_present_flag, settings, "uint32_t: 1", "buffer_removal_time_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.allow_intrabc, settings, "uint32_t: 1", "allow_intrabc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_refs_short_signaling, settings, "uint32_t: 1", "frame_refs_short_signaling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.allow_high_precision_mv, settings, "uint32_t: 1", "allow_high_precision_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.is_motion_mode_switchable, settings, "uint32_t: 1", "is_motion_mode_switchable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.use_ref_frame_mvs, settings, "uint32_t: 1", "use_ref_frame_mvs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.disable_frame_end_update_cdf, settings, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.allow_warped_motion, settings, "uint32_t: 1", "allow_warped_motion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reduced_tx_set, settings, "uint32_t: 1", "reduced_tx_set", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reference_select, settings, "uint32_t: 1", "reference_select", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.skip_mode_present, settings, "uint32_t: 1", "skip_mode_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_q_present, settings, "uint32_t: 1", "delta_q_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_lf_present, settings, "uint32_t: 1", "delta_lf_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_lf_multi, settings, "uint32_t: 1", "delta_lf_multi", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_enabled, settings, "uint32_t: 1", "segmentation_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_update_map, settings, "uint32_t: 1", "segmentation_update_map", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_temporal_update, settings, "uint32_t: 1", "segmentation_temporal_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_update_data, settings, "uint32_t: 1", "segmentation_update_data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.UsesLr, settings, "uint32_t: 1", "UsesLr", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.usesChromaLr, settings, "uint32_t: 1", "usesChromaLr", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.apply_grain, settings, "uint32_t: 1", "apply_grain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 3", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeAV1PictureInfo(const StdVideoDecodeAV1PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoDecodeAV1PictureInfoFlags<Format>(object.flags, settings, "StdVideoDecodeAV1PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1FrameType<Format>(object.frame_type, settings, "StdVideoAV1FrameType", "frame_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.current_frame_id, settings, "uint32_t", "current_frame_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.OrderHint, settings, "uint8_t", "OrderHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.primary_ref_frame, settings, "uint8_t", "primary_ref_frame", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.refresh_frame_flags, settings, "uint8_t", "refresh_frame_flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1InterpolationFilter<Format>(object.interpolation_filter, settings, "StdVideoAV1InterpolationFilter", "interpolation_filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1TxMode<Format>(object.TxMode, settings, "StdVideoAV1TxMode", "TxMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_q_res, settings, "uint8_t", "delta_q_res", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_lf_res, settings, "uint8_t", "delta_lf_res", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.SkipModeFrame, STD_VIDEO_AV1_SKIP_MODE_FRAMES, settings, "uint8_t[STD_VIDEO_AV1_SKIP_MODE_FRAMES]", "SkipModeFrame", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.coded_denom, settings, "uint8_t", "coded_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.reserved2, 3, settings, "uint8_t[3]", "reserved2", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.OrderHints, STD_VIDEO_AV1_NUM_REF_FRAMES, settings, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "OrderHints", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.expectedFrameId, STD_VIDEO_AV1_NUM_REF_FRAMES, settings, "uint32_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "expectedFrameId", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pTileInfo, settings, "const StdVideoAV1TileInfo*", "pTileInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1TileInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pQuantization, settings, "const StdVideoAV1Quantization*", "pQuantization", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Quantization<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSegmentation, settings, "const StdVideoAV1Segmentation*", "pSegmentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Segmentation<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pLoopFilter, settings, "const StdVideoAV1LoopFilter*", "pLoopFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopFilter<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pCDEF, settings, "const StdVideoAV1CDEF*", "pCDEF", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1CDEF<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pLoopRestoration, settings, "const StdVideoAV1LoopRestoration*", "pLoopRestoration", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopRestoration<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pGlobalMotion, settings, "const StdVideoAV1GlobalMotion*", "pGlobalMotion", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1GlobalMotion<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pFilmGrain, settings, "const StdVideoAV1FilmGrain*", "pFilmGrain", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1FilmGrain<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeAV1ReferenceInfoFlags(const StdVideoDecodeAV1ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.disable_frame_end_update_cdf, settings, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_enabled, settings, "uint32_t: 1", "segmentation_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeAV1ReferenceInfo(const StdVideoDecodeAV1ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoDecodeAV1ReferenceInfoFlags<Format>(object.flags, settings, "StdVideoDecodeAV1ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_type, settings, "uint8_t", "frame_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.RefFrameSignBias, settings, "uint8_t", "RefFrameSignBias", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.OrderHint, settings, "uint8_t", "OrderHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.SavedOrderHints, STD_VIDEO_AV1_NUM_REF_FRAMES, settings, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "SavedOrderHints", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeAV1DecoderModelInfo(const StdVideoEncodeAV1DecoderModelInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.buffer_delay_length_minus_1, settings, "uint8_t", "buffer_delay_length_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.buffer_removal_time_length_minus_1, settings, "uint8_t", "buffer_removal_time_length_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_presentation_time_length_minus_1, settings, "uint8_t", "frame_presentation_time_length_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.num_units_in_decoding_tick, settings, "uint32_t", "num_units_in_decoding_tick", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeAV1ExtensionHeader(const StdVideoEncodeAV1ExtensionHeader& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.temporal_id, settings, "uint8_t", "temporal_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.spatial_id, settings, "uint8_t", "spatial_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeAV1OperatingPointInfoFlags(const StdVideoEncodeAV1OperatingPointInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.decoder_model_present_for_this_op, settings, "uint32_t: 1", "decoder_model_present_for_this_op", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.low_delay_mode_flag, settings, "uint32_t: 1", "low_delay_mode_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.initial_display_delay_present_for_this_op, settings, "uint32_t: 1", "initial_display_delay_present_for_this_op", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 29", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeAV1OperatingPointInfo(const StdVideoEncodeAV1OperatingPointInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeAV1OperatingPointInfoFlags<Format>(object.flags, settings, "StdVideoEncodeAV1OperatingPointInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.operating_point_idc, settings, "uint16_t", "operating_point_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.seq_level_idx, settings, "uint8_t", "seq_level_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.seq_tier, settings, "uint8_t", "seq_tier", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.decoder_buffer_delay, settings, "uint32_t", "decoder_buffer_delay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.encoder_buffer_delay, settings, "uint32_t", "encoder_buffer_delay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.initial_display_delay_minus_1, settings, "uint8_t", "initial_display_delay_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeAV1PictureInfoFlags(const StdVideoEncodeAV1PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.error_resilient_mode, settings, "uint32_t: 1", "error_resilient_mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.disable_cdf_update, settings, "uint32_t: 1", "disable_cdf_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.use_superres, settings, "uint32_t: 1", "use_superres", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.render_and_frame_size_different, settings, "uint32_t: 1", "render_and_frame_size_different", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.allow_screen_content_tools, settings, "uint32_t: 1", "allow_screen_content_tools", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.is_filter_switchable, settings, "uint32_t: 1", "is_filter_switchable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.force_integer_mv, settings, "uint32_t: 1", "force_integer_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_size_override_flag, settings, "uint32_t: 1", "frame_size_override_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.buffer_removal_time_present_flag, settings, "uint32_t: 1", "buffer_removal_time_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.allow_intrabc, settings, "uint32_t: 1", "allow_intrabc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_refs_short_signaling, settings, "uint32_t: 1", "frame_refs_short_signaling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.allow_high_precision_mv, settings, "uint32_t: 1", "allow_high_precision_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.is_motion_mode_switchable, settings, "uint32_t: 1", "is_motion_mode_switchable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.use_ref_frame_mvs, settings, "uint32_t: 1", "use_ref_frame_mvs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.disable_frame_end_update_cdf, settings, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.allow_warped_motion, settings, "uint32_t: 1", "allow_warped_motion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reduced_tx_set, settings, "uint32_t: 1", "reduced_tx_set", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.skip_mode_present, settings, "uint32_t: 1", "skip_mode_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_q_present, settings, "uint32_t: 1", "delta_q_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_lf_present, settings, "uint32_t: 1", "delta_lf_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_lf_multi, settings, "uint32_t: 1", "delta_lf_multi", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_enabled, settings, "uint32_t: 1", "segmentation_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_update_map, settings, "uint32_t: 1", "segmentation_update_map", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_temporal_update, settings, "uint32_t: 1", "segmentation_temporal_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_update_data, settings, "uint32_t: 1", "segmentation_update_data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.UsesLr, settings, "uint32_t: 1", "UsesLr", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.usesChromaLr, settings, "uint32_t: 1", "usesChromaLr", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.show_frame, settings, "uint32_t: 1", "show_frame", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.showable_frame, settings, "uint32_t: 1", "showable_frame", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 3", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeAV1PictureInfo(const StdVideoEncodeAV1PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeAV1PictureInfoFlags<Format>(object.flags, settings, "StdVideoEncodeAV1PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1FrameType<Format>(object.frame_type, settings, "StdVideoAV1FrameType", "frame_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_presentation_time, settings, "uint32_t", "frame_presentation_time", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.current_frame_id, settings, "uint32_t", "current_frame_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.order_hint, settings, "uint8_t", "order_hint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.primary_ref_frame, settings, "uint8_t", "primary_ref_frame", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.refresh_frame_flags, settings, "uint8_t", "refresh_frame_flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.coded_denom, settings, "uint8_t", "coded_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.render_width_minus_1, settings, "uint16_t", "render_width_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.render_height_minus_1, settings, "uint16_t", "render_height_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1InterpolationFilter<Format>(object.interpolation_filter, settings, "StdVideoAV1InterpolationFilter", "interpolation_filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1TxMode<Format>(object.TxMode, settings, "StdVideoAV1TxMode", "TxMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_q_res, settings, "uint8_t", "delta_q_res", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.delta_lf_res, settings, "uint8_t", "delta_lf_res", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.ref_order_hint, STD_VIDEO_AV1_NUM_REF_FRAMES, settings, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "ref_order_hint", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.ref_frame_idx, STD_VIDEO_AV1_REFS_PER_FRAME, settings, "int8_t[STD_VIDEO_AV1_REFS_PER_FRAME]", "ref_frame_idx", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.reserved1, 3, settings, "uint8_t[3]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.delta_frame_id_minus_1, STD_VIDEO_AV1_REFS_PER_FRAME, settings, "uint32_t[STD_VIDEO_AV1_REFS_PER_FRAME]", "delta_frame_id_minus_1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pTileInfo, settings, "const StdVideoAV1TileInfo*", "pTileInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1TileInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pQuantization, settings, "const StdVideoAV1Quantization*", "pQuantization", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Quantization<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSegmentation, settings, "const StdVideoAV1Segmentation*", "pSegmentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Segmentation<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pLoopFilter, settings, "const StdVideoAV1LoopFilter*", "pLoopFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopFilter<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pCDEF, settings, "const StdVideoAV1CDEF*", "pCDEF", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1CDEF<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pLoopRestoration, settings, "const StdVideoAV1LoopRestoration*", "pLoopRestoration", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopRestoration<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pGlobalMotion, settings, "const StdVideoAV1GlobalMotion*", "pGlobalMotion", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1GlobalMotion<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pExtensionHeader, settings, "const StdVideoEncodeAV1ExtensionHeader*", "pExtensionHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1ExtensionHeader<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pBufferRemovalTimes, settings, "const uint32_t*", "pBufferRemovalTimes", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeAV1ReferenceInfoFlags(const StdVideoEncodeAV1ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.disable_frame_end_update_cdf, settings, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_enabled, settings, "uint32_t: 1", "segmentation_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoEncodeAV1ReferenceInfo(const StdVideoEncodeAV1ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoEncodeAV1ReferenceInfoFlags<Format>(object.flags, settings, "StdVideoEncodeAV1ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.RefFrameId, settings, "uint32_t", "RefFrameId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1FrameType<Format>(object.frame_type, settings, "StdVideoAV1FrameType", "frame_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.OrderHint, settings, "uint8_t", "OrderHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.reserved1, 3, settings, "uint8_t[3]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pExtensionHeader, settings, "const StdVideoEncodeAV1ExtensionHeader*", "pExtensionHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1ExtensionHeader<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9ColorConfigFlags(const StdVideoVP9ColorConfigFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.color_range, settings, "uint32_t: 1", "color_range", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 31", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9ColorConfig(const StdVideoVP9ColorConfig& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoVP9ColorConfigFlags<Format>(object.flags, settings, "StdVideoVP9ColorConfigFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.BitDepth, settings, "uint8_t", "BitDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subsampling_x, settings, "uint8_t", "subsampling_x", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subsampling_y, settings, "uint8_t", "subsampling_y", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoVP9ColorSpace<Format>(object.color_space, settings, "StdVideoVP9ColorSpace", "color_space", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9LoopFilterFlags(const StdVideoVP9LoopFilterFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.loop_filter_delta_enabled, settings, "uint32_t: 1", "loop_filter_delta_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.loop_filter_delta_update, settings, "uint32_t: 1", "loop_filter_delta_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9LoopFilter(const StdVideoVP9LoopFilter& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoVP9LoopFilterFlags<Format>(object.flags, settings, "StdVideoVP9LoopFilterFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.loop_filter_level, settings, "uint8_t", "loop_filter_level", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.loop_filter_sharpness, settings, "uint8_t", "loop_filter_sharpness", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.update_ref_delta, settings, "uint8_t", "update_ref_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.loop_filter_ref_deltas, STD_VIDEO_VP9_MAX_REF_FRAMES, settings, "int8_t[STD_VIDEO_VP9_MAX_REF_FRAMES]", "loop_filter_ref_deltas", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.update_mode_delta, settings, "uint8_t", "update_mode_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.loop_filter_mode_deltas, STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS, settings, "int8_t[STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS]", "loop_filter_mode_deltas", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9SegmentationFlags(const StdVideoVP9SegmentationFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.segmentation_update_map, settings, "uint32_t: 1", "segmentation_update_map", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_temporal_update, settings, "uint32_t: 1", "segmentation_temporal_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_update_data, settings, "uint32_t: 1", "segmentation_update_data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_abs_or_delta_update, settings, "uint32_t: 1", "segmentation_abs_or_delta_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 28", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoVP9Segmentation(const StdVideoVP9Segmentation& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoVP9SegmentationFlags<Format>(object.flags, settings, "StdVideoVP9SegmentationFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.segmentation_tree_probs, STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS, settings, "uint8_t[STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS]", "segmentation_tree_probs", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.segmentation_pred_prob, STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB, settings, "uint8_t[STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB]", "segmentation_pred_prob", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.FeatureEnabled, STD_VIDEO_VP9_MAX_SEGMENTS, settings, "uint8_t[STD_VIDEO_VP9_MAX_SEGMENTS]", "FeatureEnabled", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_double_array<Format>(object.FeatureData, STD_VIDEO_VP9_MAX_SEGMENTS, STD_VIDEO_VP9_SEG_LVL_MAX, settings, "int16_t[STD_VIDEO_VP9_MAX_SEGMENTS][STD_VIDEO_VP9_SEG_LVL_MAX]", "FeatureData", "int16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int16_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeVP9PictureInfoFlags(const StdVideoDecodeVP9PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.error_resilient_mode, settings, "uint32_t: 1", "error_resilient_mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.intra_only, settings, "uint32_t: 1", "intra_only", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.allow_high_precision_mv, settings, "uint32_t: 1", "allow_high_precision_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.refresh_frame_context, settings, "uint32_t: 1", "refresh_frame_context", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_parallel_decoding_mode, settings, "uint32_t: 1", "frame_parallel_decoding_mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.segmentation_enabled, settings, "uint32_t: 1", "segmentation_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.show_frame, settings, "uint32_t: 1", "show_frame", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.UsePrevFrameMvs, settings, "uint32_t: 1", "UsePrevFrameMvs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t: 24", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_StdVideoDecodeVP9PictureInfo(const StdVideoDecodeVP9PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_StdVideoDecodeVP9PictureInfoFlags<Format>(object.flags, settings, "StdVideoDecodeVP9PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoVP9Profile<Format>(object.profile, settings, "StdVideoVP9Profile", "profile", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoVP9FrameType<Format>(object.frame_type, settings, "StdVideoVP9FrameType", "frame_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frame_context_idx, settings, "uint8_t", "frame_context_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reset_frame_context, settings, "uint8_t", "reset_frame_context", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.refresh_frame_flags, settings, "uint8_t", "refresh_frame_flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.ref_frame_sign_bias_mask, settings, "uint8_t", "ref_frame_sign_bias_mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoVP9InterpolationFilter<Format>(object.interpolation_filter, settings, "StdVideoVP9InterpolationFilter", "interpolation_filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.base_q_idx, settings, "uint8_t", "base_q_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.delta_q_y_dc, settings, "int8_t", "delta_q_y_dc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.delta_q_uv_dc, settings, "int8_t", "delta_q_uv_dc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.delta_q_uv_ac, settings, "int8_t", "delta_q_uv_ac", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tile_cols_log2, settings, "uint8_t", "tile_cols_log2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tile_rows_log2, settings, "uint8_t", "tile_rows_log2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.reserved1, 3, settings, "uint16_t[3]", "reserved1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint16_t>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pColorConfig, settings, "const StdVideoVP9ColorConfig*", "pColorConfig", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoVP9ColorConfig<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pLoopFilter, settings, "const StdVideoVP9LoopFilter*", "pLoopFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoVP9LoopFilter<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSegmentation, settings, "const StdVideoVP9Segmentation*", "pSegmentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoVP9Segmentation<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}

//====================== Struct and Union Implementations =====================//

template <ApiDumpFormat Format>
void dump_VkExtent2D(const VkExtent2D& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExtent3D(const VkExtent3D& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.depth, settings, "uint32_t", "depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkOffset2D(const VkOffset2D& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, int32_t>(object.x, settings, "int32_t", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.y, settings, "int32_t", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkOffset3D(const VkOffset3D& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, int32_t>(object.x, settings, "int32_t", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.y, settings, "int32_t", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.z, settings, "int32_t", "z", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRect2D(const VkRect2D& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkOffset2D<Format>(object.offset, settings, "VkOffset2D", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.extent, settings, "VkExtent2D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBaseInStructure(const VkBaseInStructure& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pNext, settings, "const struct VkBaseInStructure*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBaseInStructure<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBaseOutStructure(const VkBaseOutStructure& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pNext, settings, "struct VkBaseOutStructure*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBaseOutStructure<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAllocationCallbacks(const VkAllocationCallbacks& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, void*>(object.pUserData, settings, "void*", "pUserData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_PFN_vkAllocationFunction<Format>(object.pfnAllocation, settings, "PFN_vkAllocationFunction", "pfnAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_PFN_vkReallocationFunction<Format>(object.pfnReallocation, settings, "PFN_vkReallocationFunction", "pfnReallocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_PFN_vkFreeFunction<Format>(object.pfnFree, settings, "PFN_vkFreeFunction", "pfnFree", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_PFN_vkInternalAllocationNotification<Format>(object.pfnInternalAllocation, settings, "PFN_vkInternalAllocationNotification", "pfnInternalAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_PFN_vkInternalFreeNotification<Format>(object.pfnInternalFree, settings, "PFN_vkInternalFreeNotification", "pfnInternalFree", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkApplicationInfo(const VkApplicationInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pApplicationName, settings, "const char*", "pApplicationName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.applicationVersion, settings, "uint32_t", "applicationVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pEngineName, settings, "const char*", "pEngineName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.engineVersion, settings, "uint32_t", "engineVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_api_version<Format>(object.apiVersion, settings, "uint32_t", "apiVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFormatProperties(const VkFormatProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkFormatFeatureFlags<Format>(object.linearTilingFeatures, settings, "VkFormatFeatureFlags", "linearTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags<Format>(object.optimalTilingFeatures, settings, "VkFormatFeatureFlags", "optimalTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags<Format>(object.bufferFeatures, settings, "VkFormatFeatureFlags", "bufferFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageFormatProperties(const VkImageFormatProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkExtent3D<Format>(object.maxExtent, settings, "VkExtent3D", "maxExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMipLevels, settings, "uint32_t", "maxMipLevels", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxArrayLayers, settings, "uint32_t", "maxArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.sampleCounts, settings, "VkSampleCountFlags", "sampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxResourceSize, settings, "VkDeviceSize", "maxResourceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkInstanceCreateInfo(const VkInstanceCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkInstanceCreateFlags<Format>(object.flags, settings, "VkInstanceCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pApplicationInfo, settings, "const VkApplicationInfo*", "pApplicationInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkApplicationInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enabledLayerCount, settings, "uint32_t", "enabledLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.ppEnabledLayerNames, object.enabledLayerCount, settings, "const char* const*", "ppEnabledLayerNames", "const char*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_char<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enabledExtensionCount, settings, "uint32_t", "enabledExtensionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.ppEnabledExtensionNames, object.enabledExtensionCount, settings, "const char* const*", "ppEnabledExtensionNames", "const char*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_char<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryHeap(const VkMemoryHeap& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMemoryHeapFlags<Format>(object.flags, settings, "VkMemoryHeapFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryType(const VkMemoryType& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkMemoryPropertyFlags<Format>(object.propertyFlags, settings, "VkMemoryPropertyFlags", "propertyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.heapIndex, settings, "uint32_t", "heapIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, VkBool32>(object.robustBufferAccess, settings, "VkBool32", "robustBufferAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fullDrawIndexUint32, settings, "VkBool32", "fullDrawIndexUint32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imageCubeArray, settings, "VkBool32", "imageCubeArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.independentBlend, settings, "VkBool32", "independentBlend", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.geometryShader, settings, "VkBool32", "geometryShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tessellationShader, settings, "VkBool32", "tessellationShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sampleRateShading, settings, "VkBool32", "sampleRateShading", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dualSrcBlend, settings, "VkBool32", "dualSrcBlend", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.logicOp, settings, "VkBool32", "logicOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiDrawIndirect, settings, "VkBool32", "multiDrawIndirect", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.drawIndirectFirstInstance, settings, "VkBool32", "drawIndirectFirstInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthClamp, settings, "VkBool32", "depthClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthBiasClamp, settings, "VkBool32", "depthBiasClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fillModeNonSolid, settings, "VkBool32", "fillModeNonSolid", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthBounds, settings, "VkBool32", "depthBounds", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.wideLines, settings, "VkBool32", "wideLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.largePoints, settings, "VkBool32", "largePoints", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.alphaToOne, settings, "VkBool32", "alphaToOne", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiViewport, settings, "VkBool32", "multiViewport", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.samplerAnisotropy, settings, "VkBool32", "samplerAnisotropy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.textureCompressionETC2, settings, "VkBool32", "textureCompressionETC2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.textureCompressionASTC_LDR, settings, "VkBool32", "textureCompressionASTC_LDR", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.textureCompressionBC, settings, "VkBool32", "textureCompressionBC", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.occlusionQueryPrecise, settings, "VkBool32", "occlusionQueryPrecise", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineStatisticsQuery, settings, "VkBool32", "pipelineStatisticsQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vertexPipelineStoresAndAtomics, settings, "VkBool32", "vertexPipelineStoresAndAtomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentStoresAndAtomics, settings, "VkBool32", "fragmentStoresAndAtomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderTessellationAndGeometryPointSize, settings, "VkBool32", "shaderTessellationAndGeometryPointSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderImageGatherExtended, settings, "VkBool32", "shaderImageGatherExtended", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageImageExtendedFormats, settings, "VkBool32", "shaderStorageImageExtendedFormats", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageImageMultisample, settings, "VkBool32", "shaderStorageImageMultisample", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageImageReadWithoutFormat, settings, "VkBool32", "shaderStorageImageReadWithoutFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageImageWriteWithoutFormat, settings, "VkBool32", "shaderStorageImageWriteWithoutFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderUniformBufferArrayDynamicIndexing, settings, "VkBool32", "shaderUniformBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSampledImageArrayDynamicIndexing, settings, "VkBool32", "shaderSampledImageArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageBufferArrayDynamicIndexing, settings, "VkBool32", "shaderStorageBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageImageArrayDynamicIndexing, settings, "VkBool32", "shaderStorageImageArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderClipDistance, settings, "VkBool32", "shaderClipDistance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderCullDistance, settings, "VkBool32", "shaderCullDistance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFloat64, settings, "VkBool32", "shaderFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderInt64, settings, "VkBool32", "shaderInt64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderInt16, settings, "VkBool32", "shaderInt16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderResourceResidency, settings, "VkBool32", "shaderResourceResidency", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderResourceMinLod, settings, "VkBool32", "shaderResourceMinLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseBinding, settings, "VkBool32", "sparseBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseResidencyBuffer, settings, "VkBool32", "sparseResidencyBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseResidencyImage2D, settings, "VkBool32", "sparseResidencyImage2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseResidencyImage3D, settings, "VkBool32", "sparseResidencyImage3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseResidency2Samples, settings, "VkBool32", "sparseResidency2Samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseResidency4Samples, settings, "VkBool32", "sparseResidency4Samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseResidency8Samples, settings, "VkBool32", "sparseResidency8Samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseResidency16Samples, settings, "VkBool32", "sparseResidency16Samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseResidencyAliased, settings, "VkBool32", "sparseResidencyAliased", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.variableMultisampleRate, settings, "VkBool32", "variableMultisampleRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.inheritedQueries, settings, "VkBool32", "inheritedQueries", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.maxImageDimension1D, settings, "uint32_t", "maxImageDimension1D", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxImageDimension2D, settings, "uint32_t", "maxImageDimension2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxImageDimension3D, settings, "uint32_t", "maxImageDimension3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxImageDimensionCube, settings, "uint32_t", "maxImageDimensionCube", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxImageArrayLayers, settings, "uint32_t", "maxImageArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTexelBufferElements, settings, "uint32_t", "maxTexelBufferElements", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxUniformBufferRange, settings, "uint32_t", "maxUniformBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStorageBufferRange, settings, "uint32_t", "maxStorageBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPushConstantsSize, settings, "uint32_t", "maxPushConstantsSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMemoryAllocationCount, settings, "uint32_t", "maxMemoryAllocationCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSamplerAllocationCount, settings, "uint32_t", "maxSamplerAllocationCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.bufferImageGranularity, settings, "VkDeviceSize", "bufferImageGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.sparseAddressSpaceSize, settings, "VkDeviceSize", "sparseAddressSpaceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxBoundDescriptorSets, settings, "uint32_t", "maxBoundDescriptorSets", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorSamplers, settings, "uint32_t", "maxPerStageDescriptorSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUniformBuffers, settings, "uint32_t", "maxPerStageDescriptorUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorStorageBuffers, settings, "uint32_t", "maxPerStageDescriptorStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorSampledImages, settings, "uint32_t", "maxPerStageDescriptorSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorStorageImages, settings, "uint32_t", "maxPerStageDescriptorStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorInputAttachments, settings, "uint32_t", "maxPerStageDescriptorInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageResources, settings, "uint32_t", "maxPerStageResources", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetSamplers, settings, "uint32_t", "maxDescriptorSetSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUniformBuffers, settings, "uint32_t", "maxDescriptorSetUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUniformBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetStorageBuffers, settings, "uint32_t", "maxDescriptorSetStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetStorageBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetSampledImages, settings, "uint32_t", "maxDescriptorSetSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetStorageImages, settings, "uint32_t", "maxDescriptorSetStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetInputAttachments, settings, "uint32_t", "maxDescriptorSetInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVertexInputAttributes, settings, "uint32_t", "maxVertexInputAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVertexInputBindings, settings, "uint32_t", "maxVertexInputBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVertexInputAttributeOffset, settings, "uint32_t", "maxVertexInputAttributeOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVertexInputBindingStride, settings, "uint32_t", "maxVertexInputBindingStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVertexOutputComponents, settings, "uint32_t", "maxVertexOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTessellationGenerationLevel, settings, "uint32_t", "maxTessellationGenerationLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTessellationPatchSize, settings, "uint32_t", "maxTessellationPatchSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTessellationControlPerVertexInputComponents, settings, "uint32_t", "maxTessellationControlPerVertexInputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTessellationControlPerVertexOutputComponents, settings, "uint32_t", "maxTessellationControlPerVertexOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTessellationControlPerPatchOutputComponents, settings, "uint32_t", "maxTessellationControlPerPatchOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTessellationControlTotalOutputComponents, settings, "uint32_t", "maxTessellationControlTotalOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTessellationEvaluationInputComponents, settings, "uint32_t", "maxTessellationEvaluationInputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTessellationEvaluationOutputComponents, settings, "uint32_t", "maxTessellationEvaluationOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGeometryShaderInvocations, settings, "uint32_t", "maxGeometryShaderInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGeometryInputComponents, settings, "uint32_t", "maxGeometryInputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGeometryOutputComponents, settings, "uint32_t", "maxGeometryOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGeometryOutputVertices, settings, "uint32_t", "maxGeometryOutputVertices", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGeometryTotalOutputComponents, settings, "uint32_t", "maxGeometryTotalOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFragmentInputComponents, settings, "uint32_t", "maxFragmentInputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFragmentOutputAttachments, settings, "uint32_t", "maxFragmentOutputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFragmentDualSrcAttachments, settings, "uint32_t", "maxFragmentDualSrcAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFragmentCombinedOutputResources, settings, "uint32_t", "maxFragmentCombinedOutputResources", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxComputeSharedMemorySize, settings, "uint32_t", "maxComputeSharedMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxComputeWorkGroupCount, 3, settings, "uint32_t[3]", "maxComputeWorkGroupCount", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxComputeWorkGroupInvocations, settings, "uint32_t", "maxComputeWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxComputeWorkGroupSize, 3, settings, "uint32_t[3]", "maxComputeWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subPixelPrecisionBits, settings, "uint32_t", "subPixelPrecisionBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subTexelPrecisionBits, settings, "uint32_t", "subTexelPrecisionBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.mipmapPrecisionBits, settings, "uint32_t", "mipmapPrecisionBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDrawIndexedIndexValue, settings, "uint32_t", "maxDrawIndexedIndexValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDrawIndirectCount, settings, "uint32_t", "maxDrawIndirectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxSamplerLodBias, settings, "float", "maxSamplerLodBias", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxSamplerAnisotropy, settings, "float", "maxSamplerAnisotropy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxViewports, settings, "uint32_t", "maxViewports", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxViewportDimensions, 2, settings, "uint32_t[2]", "maxViewportDimensions", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.viewportBoundsRange, 2, settings, "float[2]", "viewportBoundsRange", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, float>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewportSubPixelBits, settings, "uint32_t", "viewportSubPixelBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.minMemoryMapAlignment, settings, "size_t", "minMemoryMapAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.minTexelBufferOffsetAlignment, settings, "VkDeviceSize", "minTexelBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.minUniformBufferOffsetAlignment, settings, "VkDeviceSize", "minUniformBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.minStorageBufferOffsetAlignment, settings, "VkDeviceSize", "minStorageBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.minTexelOffset, settings, "int32_t", "minTexelOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTexelOffset, settings, "uint32_t", "maxTexelOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.minTexelGatherOffset, settings, "int32_t", "minTexelGatherOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTexelGatherOffset, settings, "uint32_t", "maxTexelGatherOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.minInterpolationOffset, settings, "float", "minInterpolationOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxInterpolationOffset, settings, "float", "maxInterpolationOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subPixelInterpolationOffsetBits, settings, "uint32_t", "subPixelInterpolationOffsetBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFramebufferWidth, settings, "uint32_t", "maxFramebufferWidth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFramebufferHeight, settings, "uint32_t", "maxFramebufferHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFramebufferLayers, settings, "uint32_t", "maxFramebufferLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.framebufferColorSampleCounts, settings, "VkSampleCountFlags", "framebufferColorSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.framebufferDepthSampleCounts, settings, "VkSampleCountFlags", "framebufferDepthSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.framebufferStencilSampleCounts, settings, "VkSampleCountFlags", "framebufferStencilSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.framebufferNoAttachmentsSampleCounts, settings, "VkSampleCountFlags", "framebufferNoAttachmentsSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxColorAttachments, settings, "uint32_t", "maxColorAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.sampledImageColorSampleCounts, settings, "VkSampleCountFlags", "sampledImageColorSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.sampledImageIntegerSampleCounts, settings, "VkSampleCountFlags", "sampledImageIntegerSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.sampledImageDepthSampleCounts, settings, "VkSampleCountFlags", "sampledImageDepthSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.sampledImageStencilSampleCounts, settings, "VkSampleCountFlags", "sampledImageStencilSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.storageImageSampleCounts, settings, "VkSampleCountFlags", "storageImageSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSampleMaskWords, settings, "uint32_t", "maxSampleMaskWords", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.timestampComputeAndGraphics, settings, "VkBool32", "timestampComputeAndGraphics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.timestampPeriod, settings, "float", "timestampPeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxClipDistances, settings, "uint32_t", "maxClipDistances", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxCullDistances, settings, "uint32_t", "maxCullDistances", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxCombinedClipAndCullDistances, settings, "uint32_t", "maxCombinedClipAndCullDistances", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.discreteQueuePriorities, settings, "uint32_t", "discreteQueuePriorities", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.pointSizeRange, 2, settings, "float[2]", "pointSizeRange", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, float>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.lineWidthRange, 2, settings, "float[2]", "lineWidthRange", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, float>);
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.pointSizeGranularity, settings, "float", "pointSizeGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.lineWidthGranularity, settings, "float", "lineWidthGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.strictLines, settings, "VkBool32", "strictLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.standardSampleLocations, settings, "VkBool32", "standardSampleLocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.optimalBufferCopyOffsetAlignment, settings, "VkDeviceSize", "optimalBufferCopyOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.optimalBufferCopyRowPitchAlignment, settings, "VkDeviceSize", "optimalBufferCopyRowPitchAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.nonCoherentAtomSize, settings, "VkDeviceSize", "nonCoherentAtomSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.memoryTypeCount, settings, "uint32_t", "memoryTypeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.memoryTypes, std::min(object.memoryTypeCount, VK_MAX_MEMORY_TYPES), settings, "VkMemoryType[VK_MAX_MEMORY_TYPES]", "memoryTypes", "VkMemoryType", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryType<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryHeapCount, settings, "uint32_t", "memoryHeapCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.memoryHeaps, std::min(object.memoryHeapCount, VK_MAX_MEMORY_HEAPS), settings, "VkMemoryHeap[VK_MAX_MEMORY_HEAPS]", "memoryHeaps", "VkMemoryHeap", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryHeap<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, VkBool32>(object.residencyStandard2DBlockShape, settings, "VkBool32", "residencyStandard2DBlockShape", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.residencyStandard2DMultisampleBlockShape, settings, "VkBool32", "residencyStandard2DMultisampleBlockShape", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.residencyStandard3DBlockShape, settings, "VkBool32", "residencyStandard3DBlockShape", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.residencyAlignedMipSize, settings, "VkBool32", "residencyAlignedMipSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.residencyNonResidentStrict, settings, "VkBool32", "residencyNonResidentStrict", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_api_version<Format>(object.apiVersion, settings, "uint32_t", "apiVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.driverVersion, settings, "uint32_t", "driverVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vendorID, settings, "uint32_t", "vendorID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceID, settings, "uint32_t", "deviceID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceType<Format>(object.deviceType, settings, "VkPhysicalDeviceType", "deviceType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.deviceName, settings, "char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]", "deviceName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.pipelineCacheUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "pipelineCacheUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceLimits<Format>(object.limits, settings, "VkPhysicalDeviceLimits", "limits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceSparseProperties<Format>(object.sparseProperties, settings, "VkPhysicalDeviceSparseProperties", "sparseProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyProperties(const VkQueueFamilyProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkQueueFlags<Format>(object.queueFlags, settings, "VkQueueFlags", "queueFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueCount, settings, "uint32_t", "queueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.timestampValidBits, settings, "uint32_t", "timestampValidBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.minImageTransferGranularity, settings, "VkExtent3D", "minImageTransferGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceQueueCreateFlags<Format>(object.flags, settings, "VkDeviceQueueCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueCount, settings, "uint32_t", "queueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pQueuePriorities, object.queueCount, settings, "const float*", "pQueuePriorities", "const float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const float>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceCreateInfo(const VkDeviceCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceCreateFlags<Format>(object.flags, settings, "VkDeviceCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueCreateInfoCount, settings, "uint32_t", "queueCreateInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pQueueCreateInfos, object.queueCreateInfoCount, settings, "const VkDeviceQueueCreateInfo*", "pQueueCreateInfos", "const VkDeviceQueueCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceQueueCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enabledLayerCount, settings, "uint32_t", "enabledLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.ppEnabledLayerNames, object.enabledLayerCount, settings, "const char* const*", "ppEnabledLayerNames", "const char*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_char<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enabledExtensionCount, settings, "uint32_t", "enabledExtensionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.ppEnabledExtensionNames, object.enabledExtensionCount, settings, "const char* const*", "ppEnabledExtensionNames", "const char*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_char<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pEnabledFeatures, settings, "const VkPhysicalDeviceFeatures*", "pEnabledFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceFeatures<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExtensionProperties(const VkExtensionProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_char<Format>(object.extensionName, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "extensionName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.specVersion, settings, "uint32_t", "specVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkLayerProperties(const VkLayerProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_char<Format>(object.layerName, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "layerName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.specVersion, settings, "uint32_t", "specVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.implementationVersion, settings, "uint32_t", "implementationVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubmitInfo(const VkSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pWaitSemaphores, object.waitSemaphoreCount, settings, "const VkSemaphore*", "pWaitSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pWaitDstStageMask, object.waitSemaphoreCount, settings, "const VkPipelineStageFlags*", "pWaitDstStageMask", "const VkPipelineStageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineStageFlags<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.commandBufferCount, settings, "uint32_t", "commandBufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCommandBuffers, object.commandBufferCount, settings, "const VkCommandBuffer*", "pCommandBuffers", "const VkCommandBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkCommandBuffer<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.signalSemaphoreCount, settings, "uint32_t", "signalSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSignalSemaphores, object.signalSemaphoreCount, settings, "const VkSemaphore*", "pSignalSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMappedMemoryRange(const VkMappedMemoryRange& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryAllocateInfo(const VkMemoryAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.allocationSize, settings, "VkDeviceSize", "allocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryTypeIndex, settings, "uint32_t", "memoryTypeIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryRequirements(const VkMemoryRequirements& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.alignment, settings, "VkDeviceSize", "alignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageSubresource(const VkImageSubresource& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImageAspectFlags<Format>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.mipLevel, settings, "uint32_t", "mipLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.arrayLayer, settings, "uint32_t", "arrayLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSparseImageFormatProperties(const VkSparseImageFormatProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImageAspectFlags<Format>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.imageGranularity, settings, "VkExtent3D", "imageGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSparseImageFormatFlags<Format>(object.flags, settings, "VkSparseImageFormatFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSparseImageMemoryBind(const VkSparseImageMemoryBind& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImageSubresource<Format>(object.subresource, settings, "VkImageSubresource", "subresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.offset, settings, "VkOffset3D", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSparseMemoryBindFlags<Format>(object.flags, settings, "VkSparseMemoryBindFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bindCount, settings, "uint32_t", "bindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pBinds, object.bindCount, settings, "const VkSparseImageMemoryBind*", "pBinds", "const VkSparseImageMemoryBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseImageMemoryBind<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSparseImageMemoryRequirements(const VkSparseImageMemoryRequirements& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkSparseImageFormatProperties<Format>(object.formatProperties, settings, "VkSparseImageFormatProperties", "formatProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.imageMipTailFirstLod, settings, "uint32_t", "imageMipTailFirstLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.imageMipTailSize, settings, "VkDeviceSize", "imageMipTailSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.imageMipTailOffset, settings, "VkDeviceSize", "imageMipTailOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.imageMipTailStride, settings, "VkDeviceSize", "imageMipTailStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSparseMemoryBind(const VkSparseMemoryBind& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, VkDeviceSize>(object.resourceOffset, settings, "VkDeviceSize", "resourceOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSparseMemoryBindFlags<Format>(object.flags, settings, "VkSparseMemoryBindFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bindCount, settings, "uint32_t", "bindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pBinds, object.bindCount, settings, "const VkSparseMemoryBind*", "pBinds", "const VkSparseMemoryBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseMemoryBind<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bindCount, settings, "uint32_t", "bindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pBinds, object.bindCount, settings, "const VkSparseMemoryBind*", "pBinds", "const VkSparseMemoryBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseMemoryBind<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindSparseInfo(const VkBindSparseInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pWaitSemaphores, object.waitSemaphoreCount, settings, "const VkSemaphore*", "pWaitSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bufferBindCount, settings, "uint32_t", "bufferBindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pBufferBinds, object.bufferBindCount, settings, "const VkSparseBufferMemoryBindInfo*", "pBufferBinds", "const VkSparseBufferMemoryBindInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseBufferMemoryBindInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.imageOpaqueBindCount, settings, "uint32_t", "imageOpaqueBindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pImageOpaqueBinds, object.imageOpaqueBindCount, settings, "const VkSparseImageOpaqueMemoryBindInfo*", "pImageOpaqueBinds", "const VkSparseImageOpaqueMemoryBindInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseImageOpaqueMemoryBindInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.imageBindCount, settings, "uint32_t", "imageBindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pImageBinds, object.imageBindCount, settings, "const VkSparseImageMemoryBindInfo*", "pImageBinds", "const VkSparseImageMemoryBindInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseImageMemoryBindInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.signalSemaphoreCount, settings, "uint32_t", "signalSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSignalSemaphores, object.signalSemaphoreCount, settings, "const VkSemaphore*", "pSignalSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFenceCreateInfo(const VkFenceCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFenceCreateFlags<Format>(object.flags, settings, "VkFenceCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphoreCreateFlags<Format>(object.flags, settings, "VkSemaphoreCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueryPoolCreateFlags<Format>(object.flags, settings, "VkQueryPoolCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueryType<Format>(object.queryType, settings, "VkQueryType", "queryType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queryCount, settings, "uint32_t", "queryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueryPipelineStatisticFlags<Format>(object.pipelineStatistics, settings, "VkQueryPipelineStatisticFlags", "pipelineStatistics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferCreateInfo(const VkBufferCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferCreateFlags<Format>(object.flags, settings, "VkBufferCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferUsageFlags<Format>(object.usage, settings, "VkBufferUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSharingMode<Format>(object.sharingMode, settings, "VkSharingMode", "sharingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    if (object.sharingMode == VK_SHARING_MODE_CONCURRENT) {
        dump_pointer_array<Format>(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const uint32_t*", "pQueueFamilyIndices", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const uint32_t*", "pQueueFamilyIndices", indents + 2);
        }
    }
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageCreateInfo(const VkImageCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageCreateFlags<Format>(object.flags, settings, "VkImageCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageType<Format>(object.imageType, settings, "VkImageType", "imageType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.mipLevels, settings, "uint32_t", "mipLevels", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.arrayLayers, settings, "uint32_t", "arrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageTiling<Format>(object.tiling, settings, "VkImageTiling", "tiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.usage, settings, "VkImageUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSharingMode<Format>(object.sharingMode, settings, "VkSharingMode", "sharingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    if (object.sharingMode == VK_SHARING_MODE_CONCURRENT) {
        dump_pointer_array<Format>(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const uint32_t*", "pQueueFamilyIndices", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const uint32_t*", "pQueueFamilyIndices", indents + 2);
        }
    }
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.initialLayout, settings, "VkImageLayout", "initialLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubresourceLayout(const VkSubresourceLayout& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.rowPitch, settings, "VkDeviceSize", "rowPitch", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.arrayPitch, settings, "VkDeviceSize", "arrayPitch", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.depthPitch, settings, "VkDeviceSize", "depthPitch", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkComponentMapping(const VkComponentMapping& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkComponentSwizzle<Format>(object.r, settings, "VkComponentSwizzle", "r", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentSwizzle<Format>(object.g, settings, "VkComponentSwizzle", "g", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentSwizzle<Format>(object.b, settings, "VkComponentSwizzle", "b", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentSwizzle<Format>(object.a, settings, "VkComponentSwizzle", "a", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageSubresourceRange(const VkImageSubresourceRange& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImageAspectFlags<Format>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.baseMipLevel, settings, "uint32_t", "baseMipLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.levelCount, settings, "uint32_t", "levelCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageViewCreateInfo(const VkImageViewCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageViewCreateFlags<Format>(object.flags, settings, "VkImageViewCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageViewType<Format>(object.viewType, settings, "VkImageViewType", "viewType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentMapping<Format>(object.components, settings, "VkComponentMapping", "components", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceRange<Format>(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCommandPoolCreateFlags<Format>(object.flags, settings, "VkCommandPoolCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCommandPool<Format>(object.commandPool, settings, "VkCommandPool", "commandPool", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCommandBufferLevel<Format>(object.level, settings, "VkCommandBufferLevel", "level", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.commandBufferCount, settings, "uint32_t", "commandBufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRenderPass<Format>(object.renderPass, settings, "VkRenderPass", "renderPass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subpass, settings, "uint32_t", "subpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFramebuffer<Format>(object.framebuffer, settings, "VkFramebuffer", "framebuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.occlusionQueryEnable, settings, "VkBool32", "occlusionQueryEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueryControlFlags<Format>(object.queryFlags, settings, "VkQueryControlFlags", "queryFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueryPipelineStatisticFlags<Format>(object.pipelineStatistics, settings, "VkQueryPipelineStatisticFlags", "pipelineStatistics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCommandBufferUsageFlags<Format>(object.flags, settings, "VkCommandBufferUsageFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getCmdBufferLevel() == VK_COMMAND_BUFFER_LEVEL_SECONDARY) {
        dump_pointer<Format>(object.pInheritanceInfo, settings, "const VkCommandBufferInheritanceInfo*", "pInheritanceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkCommandBufferInheritanceInfo<Format>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const VkCommandBufferInheritanceInfo*", "pInheritanceInfo", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const VkCommandBufferInheritanceInfo*", "pInheritanceInfo", indents + 2);
        }
    }
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferCopy(const VkBufferCopy& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, VkDeviceSize>(object.srcOffset, settings, "VkDeviceSize", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.dstOffset, settings, "VkDeviceSize", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageSubresourceLayers(const VkImageSubresourceLayers& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImageAspectFlags<Format>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.mipLevel, settings, "uint32_t", "mipLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferImageCopy(const VkBufferImageCopy& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, VkDeviceSize>(object.bufferOffset, settings, "VkDeviceSize", "bufferOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bufferRowLength, settings, "uint32_t", "bufferRowLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bufferImageHeight, settings, "uint32_t", "bufferImageHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageCopy(const VkImageCopy& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImageSubresourceLayers<Format>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferMemoryBarrier(const VkBufferMemoryBarrier& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags<Format>(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags<Format>(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageMemoryBarrier(const VkImageMemoryBarrier& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags<Format>(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags<Format>(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.oldLayout, settings, "VkImageLayout", "oldLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.newLayout, settings, "VkImageLayout", "newLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceRange<Format>(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryBarrier(const VkMemoryBarrier& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags<Format>(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags<Format>(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDispatchIndirectCommand(const VkDispatchIndirectCommand& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.x, settings, "uint32_t", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.y, settings, "uint32_t", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.z, settings, "uint32_t", "z", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCacheHeaderVersionOne(const VkPipelineCacheHeaderVersionOne& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.headerSize, settings, "uint32_t", "headerSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCacheHeaderVersion<Format>(object.headerVersion, settings, "VkPipelineCacheHeaderVersion", "headerVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vendorID, settings, "uint32_t", "vendorID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceID, settings, "uint32_t", "deviceID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.pipelineCacheUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "pipelineCacheUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkEventCreateInfo(const VkEventCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkEventCreateFlags<Format>(object.flags, settings, "VkEventCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferViewCreateInfo(const VkBufferViewCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferViewCreateFlags<Format>(object.flags, settings, "VkBufferViewCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.range, settings, "VkDeviceSize", "range", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderModuleCreateFlags<Format>(object.flags, settings, "VkShaderModuleCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.codeSize, settings, "size_t", "codeSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);

    if (settings.showShader()) {
        dump_spirv<Format>(object.pCode, object.codeSize / 4, settings, "const uint32_t*", "pCode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    } else {
        dump_special<Format>("SHADER DATA", settings, "const uint32_t*", "pCode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCacheCreateFlags<Format>(object.flags, settings, "VkPipelineCacheCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.initialDataSize, settings, "size_t", "initialDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pInitialData, settings, "const void*", "pInitialData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSpecializationMapEntry(const VkSpecializationMapEntry& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.constantID, settings, "uint32_t", "constantID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.size, settings, "size_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSpecializationInfo(const VkSpecializationInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.mapEntryCount, settings, "uint32_t", "mapEntryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pMapEntries, object.mapEntryCount, settings, "const VkSpecializationMapEntry*", "pMapEntries", "const VkSpecializationMapEntry", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationMapEntry<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pData, settings, "const void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineShaderStageCreateFlags<Format>(object.flags, settings, "VkPipelineShaderStageCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlagBits<Format>(object.stage, settings, "VkShaderStageFlagBits", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderModule<Format>(object.module, settings, "VkShaderModule", "module", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSpecializationInfo, settings, "const VkSpecializationInfo*", "pSpecializationInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCreateFlags<Format>(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineShaderStageCreateInfo<Format>(object.stage, settings, "VkPipelineShaderStageCreateInfo", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPushConstantRange(const VkPushConstantRange& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkShaderStageFlags<Format>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayoutCreateFlags<Format>(object.flags, settings, "VkPipelineLayoutCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.setLayoutCount, settings, "uint32_t", "setLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSetLayouts, object.setLayoutCount, settings, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pushConstantRangeCount, settings, "uint32_t", "pushConstantRangeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPushConstantRanges, object.pushConstantRangeCount, settings, "const VkPushConstantRange*", "pPushConstantRanges", "const VkPushConstantRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPushConstantRange<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerCreateInfo(const VkSamplerCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerCreateFlags<Format>(object.flags, settings, "VkSamplerCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFilter<Format>(object.magFilter, settings, "VkFilter", "magFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFilter<Format>(object.minFilter, settings, "VkFilter", "minFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerMipmapMode<Format>(object.mipmapMode, settings, "VkSamplerMipmapMode", "mipmapMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerAddressMode<Format>(object.addressModeU, settings, "VkSamplerAddressMode", "addressModeU", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerAddressMode<Format>(object.addressModeV, settings, "VkSamplerAddressMode", "addressModeV", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerAddressMode<Format>(object.addressModeW, settings, "VkSamplerAddressMode", "addressModeW", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.mipLodBias, settings, "float", "mipLodBias", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.anisotropyEnable, settings, "VkBool32", "anisotropyEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxAnisotropy, settings, "float", "maxAnisotropy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.compareEnable, settings, "VkBool32", "compareEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCompareOp<Format>(object.compareOp, settings, "VkCompareOp", "compareOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.minLod, settings, "float", "minLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxLod, settings, "float", "maxLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBorderColor<Format>(object.borderColor, settings, "VkBorderColor", "borderColor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.unnormalizedCoordinates, settings, "VkBool32", "unnormalizedCoordinates", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyDescriptorSet(const VkCopyDescriptorSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorSet<Format>(object.srcSet, settings, "VkDescriptorSet", "srcSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.srcBinding, settings, "uint32_t", "srcBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.srcArrayElement, settings, "uint32_t", "srcArrayElement", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorSet<Format>(object.dstSet, settings, "VkDescriptorSet", "dstSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstBinding, settings, "uint32_t", "dstBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstArrayElement, settings, "uint32_t", "dstArrayElement", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorBufferInfo(const VkDescriptorBufferInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.range, settings, "VkDeviceSize", "range", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorImageInfo(const VkDescriptorImageInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkSampler<Format>(object.sampler, settings, "VkSampler", "sampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageView<Format>(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorPoolSize(const VkDescriptorPoolSize& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkDescriptorType<Format>(object.type, settings, "VkDescriptorType", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorPoolCreateFlags<Format>(object.flags, settings, "VkDescriptorPoolCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSets, settings, "uint32_t", "maxSets", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.poolSizeCount, settings, "uint32_t", "poolSizeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPoolSizes, object.poolSizeCount, settings, "const VkDescriptorPoolSize*", "pPoolSizes", "const VkDescriptorPoolSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorPoolSize<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorPool<Format>(object.descriptorPool, settings, "VkDescriptorPool", "descriptorPool", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorSetCount, settings, "uint32_t", "descriptorSetCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSetLayouts, object.descriptorSetCount, settings, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorType<Format>(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    if ((object.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)) {
        dump_pointer_array<Format>(object.pImmutableSamplers, object.descriptorCount, settings, "const VkSampler*", "pImmutableSamplers", "const VkSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSampler<Format>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const VkSampler*", "pImmutableSamplers", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const VkSampler*", "pImmutableSamplers", indents + 2);
        }
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorSetLayoutCreateFlags<Format>(object.flags, settings, "VkDescriptorSetLayoutCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bindingCount, settings, "uint32_t", "bindingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pBindings, object.bindingCount, settings, "const VkDescriptorSetLayoutBinding*", "pBindings", "const VkDescriptorSetLayoutBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayoutBinding<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkWriteDescriptorSet(const VkWriteDescriptorSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorSet<Format>(object.dstSet, settings, "VkDescriptorSet", "dstSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstBinding, settings, "uint32_t", "dstBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstArrayElement, settings, "uint32_t", "dstArrayElement", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorType<Format>(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    if ((object.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) || (object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) || (object.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)) {
        dump_pointer_array<Format>(object.pImageInfo, object.descriptorCount, settings, "const VkDescriptorImageInfo*", "pImageInfo", "const VkDescriptorImageInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo<Format>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const VkDescriptorImageInfo*", "pImageInfo", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const VkDescriptorImageInfo*", "pImageInfo", indents + 2);
        }
    }
    dump_separate_members<Format>(settings);
    if ((object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) || (object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) {
        dump_pointer_array<Format>(object.pBufferInfo, object.descriptorCount, settings, "const VkDescriptorBufferInfo*", "pBufferInfo", "const VkDescriptorBufferInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorBufferInfo<Format>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const VkDescriptorBufferInfo*", "pBufferInfo", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const VkDescriptorBufferInfo*", "pBufferInfo", indents + 2);
        }
    }
    dump_separate_members<Format>(settings);
    if ((object.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)) {
        dump_pointer_array<Format>(object.pTexelBufferView, object.descriptorCount, settings, "const VkBufferView*", "pTexelBufferView", "const VkBufferView", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferView<Format>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const VkBufferView*", "pTexelBufferView", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const VkBufferView*", "pTexelBufferView", indents + 2);
        }
    }
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClearColorValue(const VkClearColorValue& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    dump_single_array<Format>(object.float32, 4, settings, "float[4]", "float32", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, float>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.int32, 4, settings, "int32_t[4]", "int32", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.uint32, 4, settings, "uint32_t[4]", "uint32", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.indexCount, settings, "uint32_t", "indexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceCount, settings, "uint32_t", "instanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.firstIndex, settings, "uint32_t", "firstIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.vertexOffset, settings, "int32_t", "vertexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.firstInstance, settings, "uint32_t", "firstInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDrawIndirectCommand(const VkDrawIndirectCommand& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.vertexCount, settings, "uint32_t", "vertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceCount, settings, "uint32_t", "instanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.firstVertex, settings, "uint32_t", "firstVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.firstInstance, settings, "uint32_t", "firstInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkStencilOpState(const VkStencilOpState& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStencilOp<Format>(object.failOp, settings, "VkStencilOp", "failOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStencilOp<Format>(object.passOp, settings, "VkStencilOp", "passOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStencilOp<Format>(object.depthFailOp, settings, "VkStencilOp", "depthFailOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCompareOp<Format>(object.compareOp, settings, "VkCompareOp", "compareOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.compareMask, settings, "uint32_t", "compareMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.writeMask, settings, "uint32_t", "writeMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reference, settings, "uint32_t", "reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.location, settings, "uint32_t", "location", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVertexInputBindingDescription(const VkVertexInputBindingDescription& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVertexInputRate<Format>(object.inputRate, settings, "VkVertexInputRate", "inputRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkViewport(const VkViewport& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, float>(object.x, settings, "float", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.y, settings, "float", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.width, settings, "float", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.height, settings, "float", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.minDepth, settings, "float", "minDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxDepth, settings, "float", "maxDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, VkBool32>(object.blendEnable, settings, "VkBool32", "blendEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendFactor<Format>(object.srcColorBlendFactor, settings, "VkBlendFactor", "srcColorBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendFactor<Format>(object.dstColorBlendFactor, settings, "VkBlendFactor", "dstColorBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendOp<Format>(object.colorBlendOp, settings, "VkBlendOp", "colorBlendOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendFactor<Format>(object.srcAlphaBlendFactor, settings, "VkBlendFactor", "srcAlphaBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendFactor<Format>(object.dstAlphaBlendFactor, settings, "VkBlendFactor", "dstAlphaBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendOp<Format>(object.alphaBlendOp, settings, "VkBlendOp", "alphaBlendOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkColorComponentFlags<Format>(object.colorWriteMask, settings, "VkColorComponentFlags", "colorWriteMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineColorBlendStateCreateFlags<Format>(object.flags, settings, "VkPipelineColorBlendStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.logicOpEnable, settings, "VkBool32", "logicOpEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkLogicOp<Format>(object.logicOp, settings, "VkLogicOp", "logicOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAttachments, object.attachmentCount, settings, "const VkPipelineColorBlendAttachmentState*", "pAttachments", "const VkPipelineColorBlendAttachmentState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineColorBlendAttachmentState<Format>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.blendConstants, 4, settings, "float[4]", "blendConstants", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, float>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineDepthStencilStateCreateFlags<Format>(object.flags, settings, "VkPipelineDepthStencilStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthTestEnable, settings, "VkBool32", "depthTestEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthWriteEnable, settings, "VkBool32", "depthWriteEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCompareOp<Format>(object.depthCompareOp, settings, "VkCompareOp", "depthCompareOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthBoundsTestEnable, settings, "VkBool32", "depthBoundsTestEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.stencilTestEnable, settings, "VkBool32", "stencilTestEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStencilOpState<Format>(object.front, settings, "VkStencilOpState", "front", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStencilOpState<Format>(object.back, settings, "VkStencilOpState", "back", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.minDepthBounds, settings, "float", "minDepthBounds", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxDepthBounds, settings, "float", "maxDepthBounds", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineDynamicStateCreateFlags<Format>(object.flags, settings, "VkPipelineDynamicStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dynamicStateCount, settings, "uint32_t", "dynamicStateCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDynamicStates, object.dynamicStateCount, settings, "const VkDynamicState*", "pDynamicStates", "const VkDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDynamicState<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineInputAssemblyStateCreateFlags<Format>(object.flags, settings, "VkPipelineInputAssemblyStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPrimitiveTopology<Format>(object.topology, settings, "VkPrimitiveTopology", "topology", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primitiveRestartEnable, settings, "VkBool32", "primitiveRestartEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineMultisampleStateCreateFlags<Format>(object.flags, settings, "VkPipelineMultisampleStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sampleShadingEnable, settings, "VkBool32", "sampleShadingEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.minSampleShading, settings, "float", "minSampleShading", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSampleMask, (object.rasterizationSamples + 31) / 32, settings, "const VkSampleMask*", "pSampleMask", "const VkSampleMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const VkSampleMask>);
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.alphaToCoverageEnable, settings, "VkBool32", "alphaToCoverageEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.alphaToOneEnable, settings, "VkBool32", "alphaToOneEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRasterizationStateCreateFlags<Format>(object.flags, settings, "VkPipelineRasterizationStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthClampEnable, settings, "VkBool32", "depthClampEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rasterizerDiscardEnable, settings, "VkBool32", "rasterizerDiscardEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPolygonMode<Format>(object.polygonMode, settings, "VkPolygonMode", "polygonMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCullModeFlags<Format>(object.cullMode, settings, "VkCullModeFlags", "cullMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFrontFace<Format>(object.frontFace, settings, "VkFrontFace", "frontFace", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthBiasEnable, settings, "VkBool32", "depthBiasEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.depthBiasConstantFactor, settings, "float", "depthBiasConstantFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.depthBiasClamp, settings, "float", "depthBiasClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.depthBiasSlopeFactor, settings, "float", "depthBiasSlopeFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.lineWidth, settings, "float", "lineWidth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineTessellationStateCreateFlags<Format>(object.flags, settings, "VkPipelineTessellationStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.patchControlPoints, settings, "uint32_t", "patchControlPoints", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineVertexInputStateCreateFlags<Format>(object.flags, settings, "VkPipelineVertexInputStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vertexBindingDescriptionCount, settings, "uint32_t", "vertexBindingDescriptionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pVertexBindingDescriptions, object.vertexBindingDescriptionCount, settings, "const VkVertexInputBindingDescription*", "pVertexBindingDescriptions", "const VkVertexInputBindingDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVertexInputBindingDescription<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vertexAttributeDescriptionCount, settings, "uint32_t", "vertexAttributeDescriptionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pVertexAttributeDescriptions, object.vertexAttributeDescriptionCount, settings, "const VkVertexInputAttributeDescription*", "pVertexAttributeDescriptions", "const VkVertexInputAttributeDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVertexInputAttributeDescription<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineViewportStateCreateFlags<Format>(object.flags, settings, "VkPipelineViewportStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewportCount, settings, "uint32_t", "viewportCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    if (!ApiDumpInstance::current().getIsDynamicViewport()) {
        dump_pointer_array<Format>(object.pViewports, object.viewportCount, settings, "const VkViewport*", "pViewports", "const VkViewport", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkViewport<Format>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const VkViewport*", "pViewports", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const VkViewport*", "pViewports", indents + 2);
        }
    }
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.scissorCount, settings, "uint32_t", "scissorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    if (!ApiDumpInstance::current().getIsDynamicScissor()) {
        dump_pointer_array<Format>(object.pScissors, object.scissorCount, settings, "const VkRect2D*", "pScissors", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D<Format>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const VkRect2D*", "pScissors", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const VkRect2D*", "pScissors", indents + 2);
        }
    }
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    ApiDumpInstance::current().setIsDynamicViewport(object.pDynamicState && std::count(object.pDynamicState->pDynamicStates, object.pDynamicState->pDynamicStates + object.pDynamicState->dynamicStateCount, VK_DYNAMIC_STATE_VIEWPORT) > 0);
    ApiDumpInstance::current().setIsDynamicScissor(object.pDynamicState && std::count(object.pDynamicState->pDynamicStates, object.pDynamicState->pDynamicStates + object.pDynamicState->dynamicStateCount, VK_DYNAMIC_STATE_SCISSOR));
    ApiDumpInstance::current().setIsGPLPreRasterOrFragmentShader(checkForGPLPreRasterOrFragmentShader(object));
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCreateFlags<Format>(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stageCount, settings, "uint32_t", "stageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pVertexInputState, settings, "const VkPipelineVertexInputStateCreateInfo*", "pVertexInputState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineVertexInputStateCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pInputAssemblyState, settings, "const VkPipelineInputAssemblyStateCreateInfo*", "pInputAssemblyState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineInputAssemblyStateCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pTessellationState, settings, "const VkPipelineTessellationStateCreateInfo*", "pTessellationState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineTessellationStateCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pViewportState, settings, "const VkPipelineViewportStateCreateInfo*", "pViewportState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineViewportStateCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pRasterizationState, settings, "const VkPipelineRasterizationStateCreateInfo*", "pRasterizationState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineRasterizationStateCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pMultisampleState, settings, "const VkPipelineMultisampleStateCreateInfo*", "pMultisampleState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineMultisampleStateCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDepthStencilState, settings, "const VkPipelineDepthStencilStateCreateInfo*", "pDepthStencilState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineDepthStencilStateCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pColorBlendState, settings, "const VkPipelineColorBlendStateCreateInfo*", "pColorBlendState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineColorBlendStateCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDynamicState, settings, "const VkPipelineDynamicStateCreateInfo*", "pDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineDynamicStateCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRenderPass<Format>(object.renderPass, settings, "VkRenderPass", "renderPass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subpass, settings, "uint32_t", "subpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentDescription(const VkAttachmentDescription& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkAttachmentDescriptionFlags<Format>(object.flags, settings, "VkAttachmentDescriptionFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentLoadOp<Format>(object.loadOp, settings, "VkAttachmentLoadOp", "loadOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentStoreOp<Format>(object.storeOp, settings, "VkAttachmentStoreOp", "storeOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentLoadOp<Format>(object.stencilLoadOp, settings, "VkAttachmentLoadOp", "stencilLoadOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentStoreOp<Format>(object.stencilStoreOp, settings, "VkAttachmentStoreOp", "stencilStoreOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.initialLayout, settings, "VkImageLayout", "initialLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.finalLayout, settings, "VkImageLayout", "finalLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentReference(const VkAttachmentReference& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.attachment, settings, "uint32_t", "attachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.layout, settings, "VkImageLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFramebufferCreateInfo(const VkFramebufferCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFramebufferCreateFlags<Format>(object.flags, settings, "VkFramebufferCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRenderPass<Format>(object.renderPass, settings, "VkRenderPass", "renderPass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAttachments, object.attachmentCount, settings, "const VkImageView*", "pAttachments", "const VkImageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageView<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.layers, settings, "uint32_t", "layers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubpassDependency(const VkSubpassDependency& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.srcSubpass, settings, "uint32_t", "srcSubpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstSubpass, settings, "uint32_t", "dstSubpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags<Format>(object.srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags<Format>(object.dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags<Format>(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags<Format>(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDependencyFlags<Format>(object.dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubpassDescription(const VkSubpassDescription& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkSubpassDescriptionFlags<Format>(object.flags, settings, "VkSubpassDescriptionFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineBindPoint<Format>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.inputAttachmentCount, settings, "uint32_t", "inputAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pInputAttachments, object.inputAttachmentCount, settings, "const VkAttachmentReference*", "pInputAttachments", "const VkAttachmentReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pColorAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference*", "pColorAttachments", "const VkAttachmentReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pResolveAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference*", "pResolveAttachments", "const VkAttachmentReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDepthStencilAttachment, settings, "const VkAttachmentReference*", "pDepthStencilAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preserveAttachmentCount, settings, "uint32_t", "preserveAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPreserveAttachments, object.preserveAttachmentCount, settings, "const uint32_t*", "pPreserveAttachments", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassCreateInfo(const VkRenderPassCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRenderPassCreateFlags<Format>(object.flags, settings, "VkRenderPassCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAttachments, object.attachmentCount, settings, "const VkAttachmentDescription*", "pAttachments", "const VkAttachmentDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentDescription<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subpassCount, settings, "uint32_t", "subpassCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSubpasses, object.subpassCount, settings, "const VkSubpassDescription*", "pSubpasses", "const VkSubpassDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDescription<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dependencyCount, settings, "uint32_t", "dependencyCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDependencies, object.dependencyCount, settings, "const VkSubpassDependency*", "pDependencies", "const VkSubpassDependency", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDependency<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClearDepthStencilValue(const VkClearDepthStencilValue& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, float>(object.depth, settings, "float", "depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stencil, settings, "uint32_t", "stencil", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClearRect(const VkClearRect& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkRect2D<Format>(object.rect, settings, "VkRect2D", "rect", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClearValue(const VkClearValue& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    dump_VkClearColorValue<Format>(object.color, settings, "VkClearColorValue", "color", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClearDepthStencilValue<Format>(object.depthStencil, settings, "VkClearDepthStencilValue", "depthStencil", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClearAttachment(const VkClearAttachment& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImageAspectFlags<Format>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorAttachment, settings, "uint32_t", "colorAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClearValue<Format>(object.clearValue, settings, "VkClearValue", "clearValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageBlit(const VkImageBlit& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImageSubresourceLayers<Format>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.srcOffsets, 2, settings, "VkOffset3D[2]", "srcOffsets", "VkOffset3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D<Format>);
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.dstOffsets, 2, settings, "VkOffset3D[2]", "dstOffsets", "VkOffset3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageResolve(const VkImageResolve& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImageSubresourceLayers<Format>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassBeginInfo(const VkRenderPassBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRenderPass<Format>(object.renderPass, settings, "VkRenderPass", "renderPass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFramebuffer<Format>(object.framebuffer, settings, "VkFramebuffer", "framebuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRect2D<Format>(object.renderArea, settings, "VkRect2D", "renderArea", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.clearValueCount, settings, "uint32_t", "clearValueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pClearValues, object.clearValueCount, settings, "const VkClearValue*", "pClearValues", "const VkClearValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkClearValue<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindImageMemoryInfo(const VkBindImageMemoryInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.prefersDedicatedAllocation, settings, "VkBool32", "prefersDedicatedAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.requiresDedicatedAllocation, settings, "VkBool32", "requiresDedicatedAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMemoryAllocateFlags<Format>(object.flags, settings, "VkMemoryAllocateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceMask, settings, "uint32_t", "deviceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceMask, settings, "uint32_t", "deviceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pWaitSemaphoreDeviceIndices, object.waitSemaphoreCount, settings, "const uint32_t*", "pWaitSemaphoreDeviceIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.commandBufferCount, settings, "uint32_t", "commandBufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCommandBufferDeviceMasks, object.commandBufferCount, settings, "const uint32_t*", "pCommandBufferDeviceMasks", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.signalSemaphoreCount, settings, "uint32_t", "signalSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSignalSemaphoreDeviceIndices, object.signalSemaphoreCount, settings, "const uint32_t*", "pSignalSemaphoreDeviceIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.resourceDeviceIndex, settings, "uint32_t", "resourceDeviceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryDeviceIndex, settings, "uint32_t", "memoryDeviceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceIndexCount, settings, "uint32_t", "deviceIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDeviceIndices, object.deviceIndexCount, settings, "const uint32_t*", "pDeviceIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceIndexCount, settings, "uint32_t", "deviceIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDeviceIndices, object.deviceIndexCount, settings, "const uint32_t*", "pDeviceIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.splitInstanceBindRegionCount, settings, "uint32_t", "splitInstanceBindRegionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSplitInstanceBindRegions, object.splitInstanceBindRegionCount, settings, "const VkRect2D*", "pSplitInstanceBindRegions", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.physicalDeviceCount, settings, "uint32_t", "physicalDeviceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.physicalDevices, std::min(object.physicalDeviceCount, VK_MAX_DEVICE_GROUP_SIZE), settings, "VkPhysicalDevice[VK_MAX_DEVICE_GROUP_SIZE]", "physicalDevices", "VkPhysicalDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDevice<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.subsetAllocation, settings, "VkBool32", "subsetAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.physicalDeviceCount, settings, "uint32_t", "physicalDeviceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPhysicalDevices, object.physicalDeviceCount, settings, "const VkPhysicalDevice*", "pPhysicalDevices", "const VkPhysicalDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDevice<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryRequirements2(const VkMemoryRequirements2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMemoryRequirements<Format>(object.memoryRequirements, settings, "VkMemoryRequirements", "memoryRequirements", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSparseImageMemoryRequirements<Format>(object.memoryRequirements, settings, "VkSparseImageMemoryRequirements", "memoryRequirements", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceFeatures<Format>(object.features, settings, "VkPhysicalDeviceFeatures", "features", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceProperties<Format>(object.properties, settings, "VkPhysicalDeviceProperties", "properties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFormatProperties2(const VkFormatProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatProperties<Format>(object.formatProperties, settings, "VkFormatProperties", "formatProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageFormatProperties2(const VkImageFormatProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageFormatProperties<Format>(object.imageFormatProperties, settings, "VkImageFormatProperties", "imageFormatProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageType<Format>(object.type, settings, "VkImageType", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageTiling<Format>(object.tiling, settings, "VkImageTiling", "tiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.usage, settings, "VkImageUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageCreateFlags<Format>(object.flags, settings, "VkImageCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyProperties2(const VkQueueFamilyProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueueFamilyProperties<Format>(object.queueFamilyProperties, settings, "VkQueueFamilyProperties", "queueFamilyProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    ApiDumpInstance::current().setMemoryHeapCount(object.memoryProperties.memoryHeapCount);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceMemoryProperties<Format>(object.memoryProperties, settings, "VkPhysicalDeviceMemoryProperties", "memoryProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSparseImageFormatProperties<Format>(object.properties, settings, "VkSparseImageFormatProperties", "properties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageType<Format>(object.type, settings, "VkImageType", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.usage, settings, "VkImageUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageTiling<Format>(object.tiling, settings, "VkImageTiling", "tiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.usage, settings, "VkImageUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.protectedMemory, settings, "VkBool32", "protectedMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.protectedNoFault, settings, "VkBool32", "protectedNoFault", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceQueueInfo2(const VkDeviceQueueInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceQueueCreateFlags<Format>(object.flags, settings, "VkDeviceQueueCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueIndex, settings, "uint32_t", "queueIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkProtectedSubmitInfo(const VkProtectedSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.protectedSubmit, settings, "VkBool32", "protectedSubmit", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageAspectFlagBits<Format>(object.planeAspect, settings, "VkImageAspectFlagBits", "planeAspect", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageAspectFlagBits<Format>(object.planeAspect, settings, "VkImageAspectFlagBits", "planeAspect", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalMemoryProperties(const VkExternalMemoryProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkExternalMemoryFeatureFlags<Format>(object.externalMemoryFeatures, settings, "VkExternalMemoryFeatureFlags", "externalMemoryFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlags<Format>(object.exportFromImportedHandleTypes, settings, "VkExternalMemoryHandleTypeFlags", "exportFromImportedHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlags<Format>(object.compatibleHandleTypes, settings, "VkExternalMemoryHandleTypeFlags", "compatibleHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalImageFormatProperties(const VkExternalImageFormatProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryProperties<Format>(object.externalMemoryProperties, settings, "VkExternalMemoryProperties", "externalMemoryProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferCreateFlags<Format>(object.flags, settings, "VkBufferCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferUsageFlags<Format>(object.usage, settings, "VkBufferUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalBufferProperties(const VkExternalBufferProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryProperties<Format>(object.externalMemoryProperties, settings, "VkExternalMemoryProperties", "externalMemoryProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.deviceUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "deviceUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.driverUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "driverUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.deviceLUID, VK_LUID_SIZE, settings, "uint8_t[VK_LUID_SIZE]", "deviceLUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceNodeMask, settings, "uint32_t", "deviceNodeMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceLUIDValid, settings, "VkBool32", "deviceLUIDValid", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlags<Format>(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlags<Format>(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlags<Format>(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalFenceHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalFenceProperties(const VkExternalFenceProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalFenceHandleTypeFlags<Format>(object.exportFromImportedHandleTypes, settings, "VkExternalFenceHandleTypeFlags", "exportFromImportedHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalFenceHandleTypeFlags<Format>(object.compatibleHandleTypes, settings, "VkExternalFenceHandleTypeFlags", "compatibleHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalFenceFeatureFlags<Format>(object.externalFenceFeatures, settings, "VkExternalFenceFeatureFlags", "externalFenceFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportFenceCreateInfo(const VkExportFenceCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalFenceHandleTypeFlags<Format>(object.handleTypes, settings, "VkExternalFenceHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreHandleTypeFlags<Format>(object.handleTypes, settings, "VkExternalSemaphoreHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreHandleTypeFlags<Format>(object.exportFromImportedHandleTypes, settings, "VkExternalSemaphoreHandleTypeFlags", "exportFromImportedHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreHandleTypeFlags<Format>(object.compatibleHandleTypes, settings, "VkExternalSemaphoreHandleTypeFlags", "compatibleHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreFeatureFlags<Format>(object.externalSemaphoreFeatures, settings, "VkExternalSemaphoreFeatureFlags", "externalSemaphoreFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subgroupSize, settings, "uint32_t", "subgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.supportedStages, settings, "VkShaderStageFlags", "supportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSubgroupFeatureFlags<Format>(object.supportedOperations, settings, "VkSubgroupFeatureFlags", "supportedOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.quadOperationsInAllStages, settings, "VkBool32", "quadOperationsInAllStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storageBuffer16BitAccess, settings, "VkBool32", "storageBuffer16BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.uniformAndStorageBuffer16BitAccess, settings, "VkBool32", "uniformAndStorageBuffer16BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storagePushConstant16, settings, "VkBool32", "storagePushConstant16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storageInputOutput16, settings, "VkBool32", "storageInputOutput16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.variablePointersStorageBuffer, settings, "VkBool32", "variablePointersStorageBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.variablePointers, settings, "VkBool32", "variablePointers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorUpdateTemplateEntry(const VkDescriptorUpdateTemplateEntry& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.dstBinding, settings, "uint32_t", "dstBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstArrayElement, settings, "uint32_t", "dstArrayElement", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorType<Format>(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.offset, settings, "size_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.stride, settings, "size_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorUpdateTemplateCreateFlags<Format>(object.flags, settings, "VkDescriptorUpdateTemplateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorUpdateEntryCount, settings, "uint32_t", "descriptorUpdateEntryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDescriptorUpdateEntries, object.descriptorUpdateEntryCount, settings, "const VkDescriptorUpdateTemplateEntry*", "pDescriptorUpdateEntries", "const VkDescriptorUpdateTemplateEntry", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorUpdateTemplateEntry<Format>);
    dump_separate_members<Format>(settings);
    dump_VkDescriptorUpdateTemplateType<Format>(object.templateType, settings, "VkDescriptorUpdateTemplateType", "templateType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorSetLayout<Format>(object.descriptorSetLayout, settings, "VkDescriptorSetLayout", "descriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineBindPoint<Format>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.pipelineLayout, settings, "VkPipelineLayout", "pipelineLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.set, settings, "uint32_t", "set", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerSetDescriptors, settings, "uint32_t", "maxPerSetDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxMemoryAllocationSize, settings, "VkDeviceSize", "maxMemoryAllocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.supported, settings, "VkBool32", "supported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrModelConversion<Format>(object.ycbcrModel, settings, "VkSamplerYcbcrModelConversion", "ycbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrRange<Format>(object.ycbcrRange, settings, "VkSamplerYcbcrRange", "ycbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentMapping<Format>(object.components, settings, "VkComponentMapping", "components", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.xChromaOffset, settings, "VkChromaLocation", "xChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.yChromaOffset, settings, "VkChromaLocation", "yChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFilter<Format>(object.chromaFilter, settings, "VkFilter", "chromaFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.forceExplicitReconstruction, settings, "VkBool32", "forceExplicitReconstruction", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrConversion<Format>(object.conversion, settings, "VkSamplerYcbcrConversion", "conversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.samplerYcbcrConversion, settings, "VkBool32", "samplerYcbcrConversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.combinedImageSamplerDescriptorCount, settings, "uint32_t", "combinedImageSamplerDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceMask, settings, "uint32_t", "deviceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceRenderAreaCount, settings, "uint32_t", "deviceRenderAreaCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDeviceRenderAreas, object.deviceRenderAreaCount, settings, "const VkRect2D*", "pDeviceRenderAreas", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPointClippingBehavior<Format>(object.pointClippingBehavior, settings, "VkPointClippingBehavior", "pointClippingBehavior", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.subpass, settings, "uint32_t", "subpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.inputAttachmentIndex, settings, "uint32_t", "inputAttachmentIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageAspectFlags<Format>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.aspectReferenceCount, settings, "uint32_t", "aspectReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAspectReferences, object.aspectReferenceCount, settings, "const VkInputAttachmentAspectReference*", "pAspectReferences", "const VkInputAttachmentAspectReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkInputAttachmentAspectReference<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTessellationDomainOrigin<Format>(object.domainOrigin, settings, "VkTessellationDomainOrigin", "domainOrigin", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subpassCount, settings, "uint32_t", "subpassCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pViewMasks, object.subpassCount, settings, "const uint32_t*", "pViewMasks", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dependencyCount, settings, "uint32_t", "dependencyCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pViewOffsets, object.dependencyCount, settings, "const int32_t*", "pViewOffsets", "const int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const int32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.correlationMaskCount, settings, "uint32_t", "correlationMaskCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCorrelationMasks, object.correlationMaskCount, settings, "const uint32_t*", "pCorrelationMasks", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiview, settings, "VkBool32", "multiview", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiviewGeometryShader, settings, "VkBool32", "multiviewGeometryShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiviewTessellationShader, settings, "VkBool32", "multiviewTessellationShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMultiviewViewCount, settings, "uint32_t", "maxMultiviewViewCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMultiviewInstanceIndex, settings, "uint32_t", "maxMultiviewInstanceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDrawParameters, settings, "VkBool32", "shaderDrawParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkConformanceVersion(const VkConformanceVersion& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.major, settings, "uint8_t", "major", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minor, settings, "uint8_t", "minor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subminor, settings, "uint8_t", "subminor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.patch, settings, "uint8_t", "patch", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDriverId<Format>(object.driverID, settings, "VkDriverId", "driverID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.driverName, settings, "char[VK_MAX_DRIVER_NAME_SIZE]", "driverName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.driverInfo, settings, "char[VK_MAX_DRIVER_INFO_SIZE]", "driverInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkConformanceVersion<Format>(object.conformanceVersion, settings, "VkConformanceVersion", "conformanceVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storageBuffer16BitAccess, settings, "VkBool32", "storageBuffer16BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.uniformAndStorageBuffer16BitAccess, settings, "VkBool32", "uniformAndStorageBuffer16BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storagePushConstant16, settings, "VkBool32", "storagePushConstant16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storageInputOutput16, settings, "VkBool32", "storageInputOutput16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiview, settings, "VkBool32", "multiview", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiviewGeometryShader, settings, "VkBool32", "multiviewGeometryShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiviewTessellationShader, settings, "VkBool32", "multiviewTessellationShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.variablePointersStorageBuffer, settings, "VkBool32", "variablePointersStorageBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.variablePointers, settings, "VkBool32", "variablePointers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.protectedMemory, settings, "VkBool32", "protectedMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.samplerYcbcrConversion, settings, "VkBool32", "samplerYcbcrConversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDrawParameters, settings, "VkBool32", "shaderDrawParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.deviceUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "deviceUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.driverUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "driverUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.deviceLUID, VK_LUID_SIZE, settings, "uint8_t[VK_LUID_SIZE]", "deviceLUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceNodeMask, settings, "uint32_t", "deviceNodeMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceLUIDValid, settings, "VkBool32", "deviceLUIDValid", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subgroupSize, settings, "uint32_t", "subgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.subgroupSupportedStages, settings, "VkShaderStageFlags", "subgroupSupportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSubgroupFeatureFlags<Format>(object.subgroupSupportedOperations, settings, "VkSubgroupFeatureFlags", "subgroupSupportedOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.subgroupQuadOperationsInAllStages, settings, "VkBool32", "subgroupQuadOperationsInAllStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPointClippingBehavior<Format>(object.pointClippingBehavior, settings, "VkPointClippingBehavior", "pointClippingBehavior", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMultiviewViewCount, settings, "uint32_t", "maxMultiviewViewCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMultiviewInstanceIndex, settings, "uint32_t", "maxMultiviewInstanceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.protectedNoFault, settings, "VkBool32", "protectedNoFault", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerSetDescriptors, settings, "uint32_t", "maxPerSetDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxMemoryAllocationSize, settings, "VkDeviceSize", "maxMemoryAllocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.samplerMirrorClampToEdge, settings, "VkBool32", "samplerMirrorClampToEdge", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.drawIndirectCount, settings, "VkBool32", "drawIndirectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storageBuffer8BitAccess, settings, "VkBool32", "storageBuffer8BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.uniformAndStorageBuffer8BitAccess, settings, "VkBool32", "uniformAndStorageBuffer8BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storagePushConstant8, settings, "VkBool32", "storagePushConstant8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBufferInt64Atomics, settings, "VkBool32", "shaderBufferInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSharedInt64Atomics, settings, "VkBool32", "shaderSharedInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFloat16, settings, "VkBool32", "shaderFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderInt8, settings, "VkBool32", "shaderInt8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorIndexing, settings, "VkBool32", "descriptorIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderInputAttachmentArrayDynamicIndexing, settings, "VkBool32", "shaderInputAttachmentArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderUniformTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderUniformBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSampledImageArrayNonUniformIndexing, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageImageArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderInputAttachmentArrayNonUniformIndexing, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderUniformTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingUniformBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingSampledImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingSampledImageUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingStorageImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageImageUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingStorageBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingUniformTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformTexelBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingStorageTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageTexelBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingUpdateUnusedWhilePending, settings, "VkBool32", "descriptorBindingUpdateUnusedWhilePending", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingPartiallyBound, settings, "VkBool32", "descriptorBindingPartiallyBound", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingVariableDescriptorCount, settings, "VkBool32", "descriptorBindingVariableDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.runtimeDescriptorArray, settings, "VkBool32", "runtimeDescriptorArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.samplerFilterMinmax, settings, "VkBool32", "samplerFilterMinmax", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.scalarBlockLayout, settings, "VkBool32", "scalarBlockLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imagelessFramebuffer, settings, "VkBool32", "imagelessFramebuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.uniformBufferStandardLayout, settings, "VkBool32", "uniformBufferStandardLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSubgroupExtendedTypes, settings, "VkBool32", "shaderSubgroupExtendedTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.separateDepthStencilLayouts, settings, "VkBool32", "separateDepthStencilLayouts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hostQueryReset, settings, "VkBool32", "hostQueryReset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.timelineSemaphore, settings, "VkBool32", "timelineSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bufferDeviceAddress, settings, "VkBool32", "bufferDeviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bufferDeviceAddressCaptureReplay, settings, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bufferDeviceAddressMultiDevice, settings, "VkBool32", "bufferDeviceAddressMultiDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vulkanMemoryModel, settings, "VkBool32", "vulkanMemoryModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vulkanMemoryModelDeviceScope, settings, "VkBool32", "vulkanMemoryModelDeviceScope", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vulkanMemoryModelAvailabilityVisibilityChains, settings, "VkBool32", "vulkanMemoryModelAvailabilityVisibilityChains", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderOutputViewportIndex, settings, "VkBool32", "shaderOutputViewportIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderOutputLayer, settings, "VkBool32", "shaderOutputLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.subgroupBroadcastDynamicId, settings, "VkBool32", "subgroupBroadcastDynamicId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDriverId<Format>(object.driverID, settings, "VkDriverId", "driverID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.driverName, settings, "char[VK_MAX_DRIVER_NAME_SIZE]", "driverName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.driverInfo, settings, "char[VK_MAX_DRIVER_INFO_SIZE]", "driverInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkConformanceVersion<Format>(object.conformanceVersion, settings, "VkConformanceVersion", "conformanceVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderFloatControlsIndependence<Format>(object.denormBehaviorIndependence, settings, "VkShaderFloatControlsIndependence", "denormBehaviorIndependence", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderFloatControlsIndependence<Format>(object.roundingModeIndependence, settings, "VkShaderFloatControlsIndependence", "roundingModeIndependence", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSignedZeroInfNanPreserveFloat16, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSignedZeroInfNanPreserveFloat32, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSignedZeroInfNanPreserveFloat64, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormPreserveFloat16, settings, "VkBool32", "shaderDenormPreserveFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormPreserveFloat32, settings, "VkBool32", "shaderDenormPreserveFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormPreserveFloat64, settings, "VkBool32", "shaderDenormPreserveFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormFlushToZeroFloat16, settings, "VkBool32", "shaderDenormFlushToZeroFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormFlushToZeroFloat32, settings, "VkBool32", "shaderDenormFlushToZeroFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormFlushToZeroFloat64, settings, "VkBool32", "shaderDenormFlushToZeroFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTEFloat16, settings, "VkBool32", "shaderRoundingModeRTEFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTEFloat32, settings, "VkBool32", "shaderRoundingModeRTEFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTEFloat64, settings, "VkBool32", "shaderRoundingModeRTEFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTZFloat16, settings, "VkBool32", "shaderRoundingModeRTZFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTZFloat32, settings, "VkBool32", "shaderRoundingModeRTZFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTZFloat64, settings, "VkBool32", "shaderRoundingModeRTZFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxUpdateAfterBindDescriptorsInAllPools, settings, "uint32_t", "maxUpdateAfterBindDescriptorsInAllPools", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderUniformBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSampledImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderInputAttachmentArrayNonUniformIndexingNative, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.robustBufferAccessUpdateAfterBind, settings, "VkBool32", "robustBufferAccessUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.quadDivergentImplicitLod, settings, "VkBool32", "quadDivergentImplicitLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindSamplers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindSampledImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindStorageImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindInputAttachments, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageUpdateAfterBindResources, settings, "uint32_t", "maxPerStageUpdateAfterBindResources", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindSamplers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindSampledImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindInputAttachments, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkResolveModeFlags<Format>(object.supportedDepthResolveModes, settings, "VkResolveModeFlags", "supportedDepthResolveModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkResolveModeFlags<Format>(object.supportedStencilResolveModes, settings, "VkResolveModeFlags", "supportedStencilResolveModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.independentResolveNone, settings, "VkBool32", "independentResolveNone", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.independentResolve, settings, "VkBool32", "independentResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.filterMinmaxSingleComponentFormats, settings, "VkBool32", "filterMinmaxSingleComponentFormats", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.filterMinmaxImageComponentMapping, settings, "VkBool32", "filterMinmaxImageComponentMapping", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxTimelineSemaphoreValueDifference, settings, "uint64_t", "maxTimelineSemaphoreValueDifference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.framebufferIntegerColorSampleCounts, settings, "VkSampleCountFlags", "framebufferIntegerColorSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewFormatCount, settings, "uint32_t", "viewFormatCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pViewFormats, object.viewFormatCount, settings, "const VkFormat*", "pViewFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vulkanMemoryModel, settings, "VkBool32", "vulkanMemoryModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vulkanMemoryModelDeviceScope, settings, "VkBool32", "vulkanMemoryModelDeviceScope", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vulkanMemoryModelAvailabilityVisibilityChains, settings, "VkBool32", "vulkanMemoryModelAvailabilityVisibilityChains", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hostQueryReset, settings, "VkBool32", "hostQueryReset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.timelineSemaphore, settings, "VkBool32", "timelineSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxTimelineSemaphoreValueDifference, settings, "uint64_t", "maxTimelineSemaphoreValueDifference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphoreType<Format>(object.semaphoreType, settings, "VkSemaphoreType", "semaphoreType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.initialValue, settings, "uint64_t", "initialValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.waitSemaphoreValueCount, settings, "uint32_t", "waitSemaphoreValueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pWaitSemaphoreValues, object.waitSemaphoreValueCount, settings, "const uint64_t*", "pWaitSemaphoreValues", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.signalSemaphoreValueCount, settings, "uint32_t", "signalSemaphoreValueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSignalSemaphoreValues, object.signalSemaphoreValueCount, settings, "const uint64_t*", "pSignalSemaphoreValues", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphoreWaitFlags<Format>(object.flags, settings, "VkSemaphoreWaitFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.semaphoreCount, settings, "uint32_t", "semaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSemaphores, object.semaphoreCount, settings, "const VkSemaphore*", "pSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pValues, object.semaphoreCount, settings, "const uint64_t*", "pValues", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphore<Format>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.value, settings, "uint64_t", "value", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bufferDeviceAddress, settings, "VkBool32", "bufferDeviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bufferDeviceAddressCaptureReplay, settings, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bufferDeviceAddressMultiDevice, settings, "VkBool32", "bufferDeviceAddressMultiDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.opaqueCaptureAddress, settings, "uint64_t", "opaqueCaptureAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.opaqueCaptureAddress, settings, "uint64_t", "opaqueCaptureAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storageBuffer8BitAccess, settings, "VkBool32", "storageBuffer8BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.uniformAndStorageBuffer8BitAccess, settings, "VkBool32", "uniformAndStorageBuffer8BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storagePushConstant8, settings, "VkBool32", "storagePushConstant8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBufferInt64Atomics, settings, "VkBool32", "shaderBufferInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSharedInt64Atomics, settings, "VkBool32", "shaderSharedInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFloat16, settings, "VkBool32", "shaderFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderInt8, settings, "VkBool32", "shaderInt8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderFloatControlsIndependence<Format>(object.denormBehaviorIndependence, settings, "VkShaderFloatControlsIndependence", "denormBehaviorIndependence", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderFloatControlsIndependence<Format>(object.roundingModeIndependence, settings, "VkShaderFloatControlsIndependence", "roundingModeIndependence", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSignedZeroInfNanPreserveFloat16, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSignedZeroInfNanPreserveFloat32, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSignedZeroInfNanPreserveFloat64, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormPreserveFloat16, settings, "VkBool32", "shaderDenormPreserveFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormPreserveFloat32, settings, "VkBool32", "shaderDenormPreserveFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormPreserveFloat64, settings, "VkBool32", "shaderDenormPreserveFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormFlushToZeroFloat16, settings, "VkBool32", "shaderDenormFlushToZeroFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormFlushToZeroFloat32, settings, "VkBool32", "shaderDenormFlushToZeroFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDenormFlushToZeroFloat64, settings, "VkBool32", "shaderDenormFlushToZeroFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTEFloat16, settings, "VkBool32", "shaderRoundingModeRTEFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTEFloat32, settings, "VkBool32", "shaderRoundingModeRTEFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTEFloat64, settings, "VkBool32", "shaderRoundingModeRTEFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTZFloat16, settings, "VkBool32", "shaderRoundingModeRTZFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTZFloat32, settings, "VkBool32", "shaderRoundingModeRTZFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRoundingModeRTZFloat64, settings, "VkBool32", "shaderRoundingModeRTZFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bindingCount, settings, "uint32_t", "bindingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pBindingFlags, object.bindingCount, settings, "const VkDescriptorBindingFlags*", "pBindingFlags", "const VkDescriptorBindingFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorBindingFlags<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderInputAttachmentArrayDynamicIndexing, settings, "VkBool32", "shaderInputAttachmentArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderUniformTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderUniformBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSampledImageArrayNonUniformIndexing, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageImageArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderInputAttachmentArrayNonUniformIndexing, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderUniformTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingUniformBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingSampledImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingSampledImageUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingStorageImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageImageUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingStorageBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingUniformTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformTexelBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingStorageTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageTexelBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingUpdateUnusedWhilePending, settings, "VkBool32", "descriptorBindingUpdateUnusedWhilePending", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingPartiallyBound, settings, "VkBool32", "descriptorBindingPartiallyBound", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingVariableDescriptorCount, settings, "VkBool32", "descriptorBindingVariableDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.runtimeDescriptorArray, settings, "VkBool32", "runtimeDescriptorArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxUpdateAfterBindDescriptorsInAllPools, settings, "uint32_t", "maxUpdateAfterBindDescriptorsInAllPools", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderUniformBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSampledImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderInputAttachmentArrayNonUniformIndexingNative, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.robustBufferAccessUpdateAfterBind, settings, "VkBool32", "robustBufferAccessUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.quadDivergentImplicitLod, settings, "VkBool32", "quadDivergentImplicitLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindSamplers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindSampledImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindStorageImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindInputAttachments, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageUpdateAfterBindResources, settings, "uint32_t", "maxPerStageUpdateAfterBindResources", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindSamplers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindSampledImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindInputAttachments, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorSetCount, settings, "uint32_t", "descriptorSetCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDescriptorCounts, object.descriptorSetCount, settings, "const uint32_t*", "pDescriptorCounts", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVariableDescriptorCount, settings, "uint32_t", "maxVariableDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.scalarBlockLayout, settings, "VkBool32", "scalarBlockLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerReductionMode<Format>(object.reductionMode, settings, "VkSamplerReductionMode", "reductionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.filterMinmaxSingleComponentFormats, settings, "VkBool32", "filterMinmaxSingleComponentFormats", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.filterMinmaxImageComponentMapping, settings, "VkBool32", "filterMinmaxImageComponentMapping", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.uniformBufferStandardLayout, settings, "VkBool32", "uniformBufferStandardLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSubgroupExtendedTypes, settings, "VkBool32", "shaderSubgroupExtendedTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentDescription2(const VkAttachmentDescription2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentDescriptionFlags<Format>(object.flags, settings, "VkAttachmentDescriptionFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentLoadOp<Format>(object.loadOp, settings, "VkAttachmentLoadOp", "loadOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentStoreOp<Format>(object.storeOp, settings, "VkAttachmentStoreOp", "storeOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentLoadOp<Format>(object.stencilLoadOp, settings, "VkAttachmentLoadOp", "stencilLoadOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentStoreOp<Format>(object.stencilStoreOp, settings, "VkAttachmentStoreOp", "stencilStoreOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.initialLayout, settings, "VkImageLayout", "initialLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.finalLayout, settings, "VkImageLayout", "finalLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentReference2(const VkAttachmentReference2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.attachment, settings, "uint32_t", "attachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.layout, settings, "VkImageLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageAspectFlags<Format>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubpassDescription2(const VkSubpassDescription2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSubpassDescriptionFlags<Format>(object.flags, settings, "VkSubpassDescriptionFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineBindPoint<Format>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewMask, settings, "uint32_t", "viewMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.inputAttachmentCount, settings, "uint32_t", "inputAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pInputAttachments, object.inputAttachmentCount, settings, "const VkAttachmentReference2*", "pInputAttachments", "const VkAttachmentReference2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pColorAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference2*", "pColorAttachments", "const VkAttachmentReference2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pResolveAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference2*", "pResolveAttachments", "const VkAttachmentReference2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDepthStencilAttachment, settings, "const VkAttachmentReference2*", "pDepthStencilAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preserveAttachmentCount, settings, "uint32_t", "preserveAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPreserveAttachments, object.preserveAttachmentCount, settings, "const uint32_t*", "pPreserveAttachments", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubpassDependency2(const VkSubpassDependency2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.srcSubpass, settings, "uint32_t", "srcSubpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstSubpass, settings, "uint32_t", "dstSubpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags<Format>(object.srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags<Format>(object.dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags<Format>(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags<Format>(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDependencyFlags<Format>(object.dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.viewOffset, settings, "int32_t", "viewOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubpassBeginInfo(const VkSubpassBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSubpassContents<Format>(object.contents, settings, "VkSubpassContents", "contents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubpassEndInfo(const VkSubpassEndInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRenderPassCreateFlags<Format>(object.flags, settings, "VkRenderPassCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAttachments, object.attachmentCount, settings, "const VkAttachmentDescription2*", "pAttachments", "const VkAttachmentDescription2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentDescription2<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subpassCount, settings, "uint32_t", "subpassCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSubpasses, object.subpassCount, settings, "const VkSubpassDescription2*", "pSubpasses", "const VkSubpassDescription2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDescription2<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dependencyCount, settings, "uint32_t", "dependencyCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDependencies, object.dependencyCount, settings, "const VkSubpassDependency2*", "pDependencies", "const VkSubpassDependency2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDependency2<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.correlatedViewMaskCount, settings, "uint32_t", "correlatedViewMaskCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCorrelatedViewMasks, object.correlatedViewMaskCount, settings, "const uint32_t*", "pCorrelatedViewMasks", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkResolveModeFlagBits<Format>(object.depthResolveMode, settings, "VkResolveModeFlagBits", "depthResolveMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkResolveModeFlagBits<Format>(object.stencilResolveMode, settings, "VkResolveModeFlagBits", "stencilResolveMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDepthStencilResolveAttachment, settings, "const VkAttachmentReference2*", "pDepthStencilResolveAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkResolveModeFlags<Format>(object.supportedDepthResolveModes, settings, "VkResolveModeFlags", "supportedDepthResolveModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkResolveModeFlags<Format>(object.supportedStencilResolveModes, settings, "VkResolveModeFlags", "supportedStencilResolveModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.independentResolveNone, settings, "VkBool32", "independentResolveNone", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.independentResolve, settings, "VkBool32", "independentResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.stencilUsage, settings, "VkImageUsageFlags", "stencilUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imagelessFramebuffer, settings, "VkBool32", "imagelessFramebuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageCreateFlags<Format>(object.flags, settings, "VkImageCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.usage, settings, "VkImageUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewFormatCount, settings, "uint32_t", "viewFormatCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pViewFormats, object.viewFormatCount, settings, "const VkFormat*", "pViewFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAttachments, object.attachmentCount, settings, "const VkImageView*", "pAttachments", "const VkImageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageView<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.attachmentImageInfoCount, settings, "uint32_t", "attachmentImageInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAttachmentImageInfos, object.attachmentImageInfoCount, settings, "const VkFramebufferAttachmentImageInfo*", "pAttachmentImageInfos", "const VkFramebufferAttachmentImageInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFramebufferAttachmentImageInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.separateDepthStencilLayouts, settings, "VkBool32", "separateDepthStencilLayouts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.stencilLayout, settings, "VkImageLayout", "stencilLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.stencilInitialLayout, settings, "VkImageLayout", "stencilInitialLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.stencilFinalLayout, settings, "VkImageLayout", "stencilFinalLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.robustImageAccess, settings, "VkBool32", "robustImageAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.inlineUniformBlock, settings, "VkBool32", "inlineUniformBlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingInlineUniformBlockUpdateAfterBind, settings, "VkBool32", "descriptorBindingInlineUniformBlockUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineCreationCacheControl, settings, "VkBool32", "pipelineCreationCacheControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.privateData, settings, "VkBool32", "privateData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDemoteToHelperInvocation, settings, "VkBool32", "shaderDemoteToHelperInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderTerminateInvocation, settings, "VkBool32", "shaderTerminateInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.subgroupSizeControl, settings, "VkBool32", "subgroupSizeControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.computeFullSubgroups, settings, "VkBool32", "computeFullSubgroups", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.synchronization2, settings, "VkBool32", "synchronization2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.textureCompressionASTC_HDR, settings, "VkBool32", "textureCompressionASTC_HDR", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderZeroInitializeWorkgroupMemory, settings, "VkBool32", "shaderZeroInitializeWorkgroupMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dynamicRendering, settings, "VkBool32", "dynamicRendering", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderIntegerDotProduct, settings, "VkBool32", "shaderIntegerDotProduct", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.maintenance4, settings, "VkBool32", "maintenance4", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minSubgroupSize, settings, "uint32_t", "minSubgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSubgroupSize, settings, "uint32_t", "maxSubgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxComputeWorkgroupSubgroups, settings, "uint32_t", "maxComputeWorkgroupSubgroups", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.requiredSubgroupSizeStages, settings, "VkShaderStageFlags", "requiredSubgroupSizeStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxInlineUniformBlockSize, settings, "uint32_t", "maxInlineUniformBlockSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxInlineUniformTotalSize, settings, "uint32_t", "maxInlineUniformTotalSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct8BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct8BitSignedAccelerated, settings, "VkBool32", "integerDotProduct8BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct8BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct16BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct16BitSignedAccelerated, settings, "VkBool32", "integerDotProduct16BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct16BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct32BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct32BitSignedAccelerated, settings, "VkBool32", "integerDotProduct32BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct32BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct64BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct64BitSignedAccelerated, settings, "VkBool32", "integerDotProduct64BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct64BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating8BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating16BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating32BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating64BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.storageTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "storageTexelBufferOffsetAlignmentBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storageTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "storageTexelBufferOffsetSingleTexelAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.uniformTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "uniformTexelBufferOffsetAlignmentBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.uniformTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "uniformTexelBufferOffsetSingleTexelAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxBufferSize, settings, "VkDeviceSize", "maxBufferSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.name, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.version, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "version", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkToolPurposeFlags<Format>(object.purposes, settings, "VkToolPurposeFlags", "purposes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.layer, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "layer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.privateData, settings, "VkBool32", "privateData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.privateDataSlotRequestCount, settings, "uint32_t", "privateDataSlotRequestCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPrivateDataSlotCreateFlags<Format>(object.flags, settings, "VkPrivateDataSlotCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryBarrier2(const VkMemoryBarrier2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags2<Format>(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags2<Format>(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferMemoryBarrier2(const VkBufferMemoryBarrier2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags2<Format>(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags2<Format>(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageMemoryBarrier2(const VkImageMemoryBarrier2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags2<Format>(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags2<Format>(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.oldLayout, settings, "VkImageLayout", "oldLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.newLayout, settings, "VkImageLayout", "newLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceRange<Format>(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDependencyInfo(const VkDependencyInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDependencyFlags<Format>(object.dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryBarrierCount, settings, "uint32_t", "memoryBarrierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pMemoryBarriers, object.memoryBarrierCount, settings, "const VkMemoryBarrier2*", "pMemoryBarriers", "const VkMemoryBarrier2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryBarrier2<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bufferMemoryBarrierCount, settings, "uint32_t", "bufferMemoryBarrierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pBufferMemoryBarriers, object.bufferMemoryBarrierCount, settings, "const VkBufferMemoryBarrier2*", "pBufferMemoryBarriers", "const VkBufferMemoryBarrier2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferMemoryBarrier2<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.imageMemoryBarrierCount, settings, "uint32_t", "imageMemoryBarrierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pImageMemoryBarriers, object.imageMemoryBarrierCount, settings, "const VkImageMemoryBarrier2*", "pImageMemoryBarriers", "const VkImageMemoryBarrier2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageMemoryBarrier2<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphore<Format>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.value, settings, "uint64_t", "value", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.stageMask, settings, "VkPipelineStageFlags2", "stageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceIndex, settings, "uint32_t", "deviceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCommandBuffer<Format>(object.commandBuffer, settings, "VkCommandBuffer", "commandBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceMask, settings, "uint32_t", "deviceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubmitInfo2(const VkSubmitInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSubmitFlags<Format>(object.flags, settings, "VkSubmitFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.waitSemaphoreInfoCount, settings, "uint32_t", "waitSemaphoreInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pWaitSemaphoreInfos, object.waitSemaphoreInfoCount, settings, "const VkSemaphoreSubmitInfo*", "pWaitSemaphoreInfos", "const VkSemaphoreSubmitInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphoreSubmitInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.commandBufferInfoCount, settings, "uint32_t", "commandBufferInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCommandBufferInfos, object.commandBufferInfoCount, settings, "const VkCommandBufferSubmitInfo*", "pCommandBufferInfos", "const VkCommandBufferSubmitInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkCommandBufferSubmitInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.signalSemaphoreInfoCount, settings, "uint32_t", "signalSemaphoreInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSignalSemaphoreInfos, object.signalSemaphoreInfoCount, settings, "const VkSemaphoreSubmitInfo*", "pSignalSemaphoreInfos", "const VkSemaphoreSubmitInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphoreSubmitInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSynchronization2Features(const VkPhysicalDeviceSynchronization2Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.synchronization2, settings, "VkBool32", "synchronization2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferCopy2(const VkBufferCopy2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.srcOffset, settings, "VkDeviceSize", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.dstOffset, settings, "VkDeviceSize", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyBufferInfo2(const VkCopyBufferInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.srcBuffer, settings, "VkBuffer", "srcBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.dstBuffer, settings, "VkBuffer", "dstBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkBufferCopy2*", "pRegions", "const VkBufferCopy2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferCopy2<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageCopy2(const VkImageCopy2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyImageInfo2(const VkCopyImageInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkImageCopy2*", "pRegions", "const VkImageCopy2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCopy2<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferImageCopy2(const VkBufferImageCopy2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.bufferOffset, settings, "VkDeviceSize", "bufferOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bufferRowLength, settings, "uint32_t", "bufferRowLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bufferImageHeight, settings, "uint32_t", "bufferImageHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyBufferToImageInfo2(const VkCopyBufferToImageInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.srcBuffer, settings, "VkBuffer", "srcBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkBufferImageCopy2*", "pRegions", "const VkBufferImageCopy2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferImageCopy2<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyImageToBufferInfo2(const VkCopyImageToBufferInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.dstBuffer, settings, "VkBuffer", "dstBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkBufferImageCopy2*", "pRegions", "const VkBufferImageCopy2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferImageCopy2<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.textureCompressionASTC_HDR, settings, "VkBool32", "textureCompressionASTC_HDR", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFormatProperties3(const VkFormatProperties3& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.linearTilingFeatures, settings, "VkFormatFeatureFlags2", "linearTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.optimalTilingFeatures, settings, "VkFormatFeatureFlags2", "optimalTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.bufferFeatures, settings, "VkFormatFeatureFlags2", "bufferFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.maintenance4, settings, "VkBool32", "maintenance4", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance4Properties(const VkPhysicalDeviceMaintenance4Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxBufferSize, settings, "VkDeviceSize", "maxBufferSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pCreateInfo, settings, "const VkBufferCreateInfo*", "pCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferCreateInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pCreateInfo, settings, "const VkImageCreateInfo*", "pCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_VkImageAspectFlagBits<Format>(object.planeAspect, settings, "VkImageAspectFlagBits", "planeAspect", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCreationFeedback(const VkPipelineCreationFeedback& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkPipelineCreationFeedbackFlags<Format>(object.flags, settings, "VkPipelineCreationFeedbackFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.duration, settings, "uint64_t", "duration", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pPipelineCreationFeedback, settings, "VkPipelineCreationFeedback*", "pPipelineCreationFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineCreationFeedback<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pipelineStageCreationFeedbackCount, settings, "uint32_t", "pipelineStageCreationFeedbackCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPipelineStageCreationFeedbacks, object.pipelineStageCreationFeedbackCount, settings, "VkPipelineCreationFeedback*", "pPipelineStageCreationFeedbacks", "VkPipelineCreationFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineCreationFeedback<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderTerminateInvocationFeatures(const VkPhysicalDeviceShaderTerminateInvocationFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderTerminateInvocation, settings, "VkBool32", "shaderTerminateInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDemoteToHelperInvocation, settings, "VkBool32", "shaderDemoteToHelperInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePipelineCreationCacheControlFeatures(const VkPhysicalDevicePipelineCreationCacheControlFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineCreationCacheControl, settings, "VkBool32", "pipelineCreationCacheControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderZeroInitializeWorkgroupMemory, settings, "VkBool32", "shaderZeroInitializeWorkgroupMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageRobustnessFeatures(const VkPhysicalDeviceImageRobustnessFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.robustImageAccess, settings, "VkBool32", "robustImageAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSubgroupSizeControlFeatures(const VkPhysicalDeviceSubgroupSizeControlFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.subgroupSizeControl, settings, "VkBool32", "subgroupSizeControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.computeFullSubgroups, settings, "VkBool32", "computeFullSubgroups", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSubgroupSizeControlProperties(const VkPhysicalDeviceSubgroupSizeControlProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minSubgroupSize, settings, "uint32_t", "minSubgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSubgroupSize, settings, "uint32_t", "maxSubgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxComputeWorkgroupSubgroups, settings, "uint32_t", "maxComputeWorkgroupSubgroups", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.requiredSubgroupSizeStages, settings, "VkShaderStageFlags", "requiredSubgroupSizeStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.requiredSubgroupSize, settings, "uint32_t", "requiredSubgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceInlineUniformBlockFeatures(const VkPhysicalDeviceInlineUniformBlockFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.inlineUniformBlock, settings, "VkBool32", "inlineUniformBlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingInlineUniformBlockUpdateAfterBind, settings, "VkBool32", "descriptorBindingInlineUniformBlockUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceInlineUniformBlockProperties(const VkPhysicalDeviceInlineUniformBlockProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxInlineUniformBlockSize, settings, "uint32_t", "maxInlineUniformBlockSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkWriteDescriptorSetInlineUniformBlock(const VkWriteDescriptorSetInlineUniformBlock& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dataSize, settings, "uint32_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pData, settings, "const void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorPoolInlineUniformBlockCreateInfo(const VkDescriptorPoolInlineUniformBlockCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxInlineUniformBlockBindings, settings, "uint32_t", "maxInlineUniformBlockBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderIntegerDotProductFeatures(const VkPhysicalDeviceShaderIntegerDotProductFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderIntegerDotProduct, settings, "VkBool32", "shaderIntegerDotProduct", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderIntegerDotProductProperties(const VkPhysicalDeviceShaderIntegerDotProductProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct8BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct8BitSignedAccelerated, settings, "VkBool32", "integerDotProduct8BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct8BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct16BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct16BitSignedAccelerated, settings, "VkBool32", "integerDotProduct16BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct16BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct32BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct32BitSignedAccelerated, settings, "VkBool32", "integerDotProduct32BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct32BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct64BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct64BitSignedAccelerated, settings, "VkBool32", "integerDotProduct64BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProduct64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct64BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating8BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating16BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating32BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating64BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTexelBufferAlignmentProperties(const VkPhysicalDeviceTexelBufferAlignmentProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.storageTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "storageTexelBufferOffsetAlignmentBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.storageTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "storageTexelBufferOffsetSingleTexelAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.uniformTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "uniformTexelBufferOffsetAlignmentBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.uniformTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "uniformTexelBufferOffsetSingleTexelAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageBlit2(const VkImageBlit2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.srcOffsets, 2, settings, "VkOffset3D[2]", "srcOffsets", "VkOffset3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D<Format>);
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.dstOffsets, 2, settings, "VkOffset3D[2]", "dstOffsets", "VkOffset3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBlitImageInfo2(const VkBlitImageInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkImageBlit2*", "pRegions", "const VkImageBlit2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageBlit2<Format>);
    dump_separate_members<Format>(settings);
    dump_VkFilter<Format>(object.filter, settings, "VkFilter", "filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageResolve2(const VkImageResolve2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkResolveImageInfo2(const VkResolveImageInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkImageResolve2*", "pRegions", "const VkImageResolve2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageResolve2<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderingAttachmentInfo(const VkRenderingAttachmentInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageView<Format>(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkResolveModeFlagBits<Format>(object.resolveMode, settings, "VkResolveModeFlagBits", "resolveMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageView<Format>(object.resolveImageView, settings, "VkImageView", "resolveImageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.resolveImageLayout, settings, "VkImageLayout", "resolveImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentLoadOp<Format>(object.loadOp, settings, "VkAttachmentLoadOp", "loadOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentStoreOp<Format>(object.storeOp, settings, "VkAttachmentStoreOp", "storeOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClearValue<Format>(object.clearValue, settings, "VkClearValue", "clearValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderingInfo(const VkRenderingInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRenderingFlags<Format>(object.flags, settings, "VkRenderingFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRect2D<Format>(object.renderArea, settings, "VkRect2D", "renderArea", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewMask, settings, "uint32_t", "viewMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pColorAttachments, object.colorAttachmentCount, settings, "const VkRenderingAttachmentInfo*", "pColorAttachments", "const VkRenderingAttachmentInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderingAttachmentInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDepthAttachment, settings, "const VkRenderingAttachmentInfo*", "pDepthAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderingAttachmentInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStencilAttachment, settings, "const VkRenderingAttachmentInfo*", "pStencilAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderingAttachmentInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewMask, settings, "uint32_t", "viewMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    if (!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()) {
        dump_type<Format, uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "uint32_t", "colorAttachmentCount", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "uint32_t", "colorAttachmentCount", indents + 2);
        }
    }
    dump_separate_members<Format>(settings);
    if (!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()) {
        dump_pointer_array<Format>(object.pColorAttachmentFormats, object.colorAttachmentCount, settings, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat<Format>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const VkFormat*", "pColorAttachmentFormats", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const VkFormat*", "pColorAttachmentFormats", indents + 2);
        }
    }
    dump_separate_members<Format>(settings);
    if (!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()) {
        dump_VkFormat<Format>(object.depthAttachmentFormat, settings, "VkFormat", "depthAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "VkFormat", "depthAttachmentFormat", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "VkFormat", "depthAttachmentFormat", indents + 2);
        }
    }
    dump_separate_members<Format>(settings);
    if (!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()) {
        dump_VkFormat<Format>(object.stencilAttachmentFormat, settings, "VkFormat", "stencilAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "VkFormat", "stencilAttachmentFormat", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "VkFormat", "stencilAttachmentFormat", indents + 2);
        }
    }
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDynamicRenderingFeatures(const VkPhysicalDeviceDynamicRenderingFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dynamicRendering, settings, "VkBool32", "dynamicRendering", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferInheritanceRenderingInfo(const VkCommandBufferInheritanceRenderingInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRenderingFlags<Format>(object.flags, settings, "VkRenderingFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewMask, settings, "uint32_t", "viewMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pColorAttachmentFormats, object.colorAttachmentCount, settings, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat<Format>);
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.depthAttachmentFormat, settings, "VkFormat", "depthAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.stencilAttachmentFormat, settings, "VkFormat", "stencilAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVulkan14Features(const VkPhysicalDeviceVulkan14Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.globalPriorityQuery, settings, "VkBool32", "globalPriorityQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSubgroupRotate, settings, "VkBool32", "shaderSubgroupRotate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSubgroupRotateClustered, settings, "VkBool32", "shaderSubgroupRotateClustered", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFloatControls2, settings, "VkBool32", "shaderFloatControls2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderExpectAssume, settings, "VkBool32", "shaderExpectAssume", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rectangularLines, settings, "VkBool32", "rectangularLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bresenhamLines, settings, "VkBool32", "bresenhamLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.smoothLines, settings, "VkBool32", "smoothLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.stippledRectangularLines, settings, "VkBool32", "stippledRectangularLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.stippledBresenhamLines, settings, "VkBool32", "stippledBresenhamLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.stippledSmoothLines, settings, "VkBool32", "stippledSmoothLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vertexAttributeInstanceRateDivisor, settings, "VkBool32", "vertexAttributeInstanceRateDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vertexAttributeInstanceRateZeroDivisor, settings, "VkBool32", "vertexAttributeInstanceRateZeroDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.indexTypeUint8, settings, "VkBool32", "indexTypeUint8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dynamicRenderingLocalRead, settings, "VkBool32", "dynamicRenderingLocalRead", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.maintenance5, settings, "VkBool32", "maintenance5", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.maintenance6, settings, "VkBool32", "maintenance6", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineProtectedAccess, settings, "VkBool32", "pipelineProtectedAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineRobustness, settings, "VkBool32", "pipelineRobustness", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hostImageCopy, settings, "VkBool32", "hostImageCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pushDescriptor, settings, "VkBool32", "pushDescriptor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVulkan14Properties(const VkPhysicalDeviceVulkan14Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.lineSubPixelPrecisionBits, settings, "uint32_t", "lineSubPixelPrecisionBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVertexAttribDivisor, settings, "uint32_t", "maxVertexAttribDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.supportsNonZeroFirstInstance, settings, "VkBool32", "supportsNonZeroFirstInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPushDescriptors, settings, "uint32_t", "maxPushDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dynamicRenderingLocalReadDepthStencilAttachments, settings, "VkBool32", "dynamicRenderingLocalReadDepthStencilAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dynamicRenderingLocalReadMultisampledAttachments, settings, "VkBool32", "dynamicRenderingLocalReadMultisampledAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.earlyFragmentMultisampleCoverageAfterSampleCounting, settings, "VkBool32", "earlyFragmentMultisampleCoverageAfterSampleCounting", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.earlyFragmentSampleMaskTestBeforeSampleCounting, settings, "VkBool32", "earlyFragmentSampleMaskTestBeforeSampleCounting", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthStencilSwizzleOneSupport, settings, "VkBool32", "depthStencilSwizzleOneSupport", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.polygonModePointSize, settings, "VkBool32", "polygonModePointSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nonStrictSinglePixelWideLinesUseParallelogram, settings, "VkBool32", "nonStrictSinglePixelWideLinesUseParallelogram", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nonStrictWideLinesUseParallelogram, settings, "VkBool32", "nonStrictWideLinesUseParallelogram", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.blockTexelViewCompatibleMultipleLayers, settings, "VkBool32", "blockTexelViewCompatibleMultipleLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxCombinedImageSamplerDescriptorCount, settings, "uint32_t", "maxCombinedImageSamplerDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShadingRateClampCombinerInputs, settings, "VkBool32", "fragmentShadingRateClampCombinerInputs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessBufferBehavior<Format>(object.defaultRobustnessStorageBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessBufferBehavior<Format>(object.defaultRobustnessUniformBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessBufferBehavior<Format>(object.defaultRobustnessVertexInputs, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessVertexInputs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessImageBehavior<Format>(object.defaultRobustnessImages, settings, "VkPipelineRobustnessImageBehavior", "defaultRobustnessImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.copySrcLayoutCount, settings, "uint32_t", "copySrcLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCopySrcLayouts, object.copySrcLayoutCount, settings, "VkImageLayout*", "pCopySrcLayouts", "VkImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.copyDstLayoutCount, settings, "uint32_t", "copyDstLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCopyDstLayouts, object.copyDstLayoutCount, settings, "VkImageLayout*", "pCopyDstLayouts", "VkImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout<Format>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.optimalTilingLayoutUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "optimalTilingLayoutUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.identicalMemoryTypeRequirements, settings, "VkBool32", "identicalMemoryTypeRequirements", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceQueueGlobalPriorityCreateInfo(const VkDeviceQueueGlobalPriorityCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueueGlobalPriority<Format>(object.globalPriority, settings, "VkQueueGlobalPriority", "globalPriority", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceGlobalPriorityQueryFeatures(const VkPhysicalDeviceGlobalPriorityQueryFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.globalPriorityQuery, settings, "VkBool32", "globalPriorityQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyGlobalPriorityProperties(const VkQueueFamilyGlobalPriorityProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.priorityCount, settings, "uint32_t", "priorityCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.priorities, std::min(object.priorityCount, VK_MAX_GLOBAL_PRIORITY_SIZE), settings, "VkQueueGlobalPriority[VK_MAX_GLOBAL_PRIORITY_SIZE]", "priorities", "VkQueueGlobalPriority", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkQueueGlobalPriority<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceIndexTypeUint8Features(const VkPhysicalDeviceIndexTypeUint8Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.indexTypeUint8, settings, "VkBool32", "indexTypeUint8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryMapInfo(const VkMemoryMapInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMemoryMapFlags<Format>(object.flags, settings, "VkMemoryMapFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryUnmapInfo(const VkMemoryUnmapInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMemoryUnmapFlags<Format>(object.flags, settings, "VkMemoryUnmapFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance5Features(const VkPhysicalDeviceMaintenance5Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.maintenance5, settings, "VkBool32", "maintenance5", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance5Properties(const VkPhysicalDeviceMaintenance5Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.earlyFragmentMultisampleCoverageAfterSampleCounting, settings, "VkBool32", "earlyFragmentMultisampleCoverageAfterSampleCounting", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.earlyFragmentSampleMaskTestBeforeSampleCounting, settings, "VkBool32", "earlyFragmentSampleMaskTestBeforeSampleCounting", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthStencilSwizzleOneSupport, settings, "VkBool32", "depthStencilSwizzleOneSupport", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.polygonModePointSize, settings, "VkBool32", "polygonModePointSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nonStrictSinglePixelWideLinesUseParallelogram, settings, "VkBool32", "nonStrictSinglePixelWideLinesUseParallelogram", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nonStrictWideLinesUseParallelogram, settings, "VkBool32", "nonStrictWideLinesUseParallelogram", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubresourceLayout2(const VkSubresourceLayout2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSubresourceLayout<Format>(object.subresourceLayout, settings, "VkSubresourceLayout", "subresourceLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageSubresource2(const VkImageSubresource2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresource<Format>(object.imageSubresource, settings, "VkImageSubresource", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceImageSubresourceInfo(const VkDeviceImageSubresourceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pCreateInfo, settings, "const VkImageCreateInfo*", "pCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSubresource, settings, "const VkImageSubresource2*", "pSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageSubresource2<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferUsageFlags2CreateInfo(const VkBufferUsageFlags2CreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferUsageFlags2<Format>(object.usage, settings, "VkBufferUsageFlags2", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance6Features(const VkPhysicalDeviceMaintenance6Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.maintenance6, settings, "VkBool32", "maintenance6", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance6Properties(const VkPhysicalDeviceMaintenance6Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.blockTexelViewCompatibleMultipleLayers, settings, "VkBool32", "blockTexelViewCompatibleMultipleLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxCombinedImageSamplerDescriptorCount, settings, "uint32_t", "maxCombinedImageSamplerDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShadingRateClampCombinerInputs, settings, "VkBool32", "fragmentShadingRateClampCombinerInputs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindMemoryStatus(const VkBindMemoryStatus& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pResult, settings, "VkResult*", "pResult", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkResult<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceHostImageCopyFeatures(const VkPhysicalDeviceHostImageCopyFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hostImageCopy, settings, "VkBool32", "hostImageCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceHostImageCopyProperties(const VkPhysicalDeviceHostImageCopyProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.copySrcLayoutCount, settings, "uint32_t", "copySrcLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCopySrcLayouts, object.copySrcLayoutCount, settings, "VkImageLayout*", "pCopySrcLayouts", "VkImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.copyDstLayoutCount, settings, "uint32_t", "copyDstLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCopyDstLayouts, object.copyDstLayoutCount, settings, "VkImageLayout*", "pCopyDstLayouts", "VkImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout<Format>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.optimalTilingLayoutUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "optimalTilingLayoutUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.identicalMemoryTypeRequirements, settings, "VkBool32", "identicalMemoryTypeRequirements", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryToImageCopy(const VkMemoryToImageCopy& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pHostPointer, settings, "const void*", "pHostPointer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryRowLength, settings, "uint32_t", "memoryRowLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryImageHeight, settings, "uint32_t", "memoryImageHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageToMemoryCopy(const VkImageToMemoryCopy& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pHostPointer, settings, "void*", "pHostPointer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryRowLength, settings, "uint32_t", "memoryRowLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryImageHeight, settings, "uint32_t", "memoryImageHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyMemoryToImageInfo(const VkCopyMemoryToImageInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkHostImageCopyFlags<Format>(object.flags, settings, "VkHostImageCopyFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkMemoryToImageCopy*", "pRegions", "const VkMemoryToImageCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryToImageCopy<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyImageToMemoryInfo(const VkCopyImageToMemoryInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkHostImageCopyFlags<Format>(object.flags, settings, "VkHostImageCopyFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkImageToMemoryCopy*", "pRegions", "const VkImageToMemoryCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageToMemoryCopy<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyImageToImageInfo(const VkCopyImageToImageInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkHostImageCopyFlags<Format>(object.flags, settings, "VkHostImageCopyFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkImageCopy2*", "pRegions", "const VkImageCopy2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCopy2<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkHostImageLayoutTransitionInfo(const VkHostImageLayoutTransitionInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.oldLayout, settings, "VkImageLayout", "oldLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.newLayout, settings, "VkImageLayout", "newLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceRange<Format>(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubresourceHostMemcpySize(const VkSubresourceHostMemcpySize& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkHostImageCopyDevicePerformanceQuery(const VkHostImageCopyDevicePerformanceQuery& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.optimalDeviceAccess, settings, "VkBool32", "optimalDeviceAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.identicalMemoryLayout, settings, "VkBool32", "identicalMemoryLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderSubgroupRotateFeatures(const VkPhysicalDeviceShaderSubgroupRotateFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSubgroupRotate, settings, "VkBool32", "shaderSubgroupRotate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSubgroupRotateClustered, settings, "VkBool32", "shaderSubgroupRotateClustered", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderFloatControls2Features(const VkPhysicalDeviceShaderFloatControls2Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFloatControls2, settings, "VkBool32", "shaderFloatControls2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderExpectAssumeFeatures(const VkPhysicalDeviceShaderExpectAssumeFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderExpectAssume, settings, "VkBool32", "shaderExpectAssume", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCreateFlags2CreateInfo(const VkPipelineCreateFlags2CreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCreateFlags2<Format>(object.flags, settings, "VkPipelineCreateFlags2", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePushDescriptorProperties(const VkPhysicalDevicePushDescriptorProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPushDescriptors, settings, "uint32_t", "maxPushDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindDescriptorSetsInfo(const VkBindDescriptorSetsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.firstSet, settings, "uint32_t", "firstSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorSetCount, settings, "uint32_t", "descriptorSetCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDescriptorSets, object.descriptorSetCount, settings, "const VkDescriptorSet*", "pDescriptorSets", "const VkDescriptorSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSet<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dynamicOffsetCount, settings, "uint32_t", "dynamicOffsetCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDynamicOffsets, object.dynamicOffsetCount, settings, "const uint32_t*", "pDynamicOffsets", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPushConstantsInfo(const VkPushConstantsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pValues, settings, "const void*", "pValues", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPushDescriptorSetInfo(const VkPushDescriptorSetInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.set, settings, "uint32_t", "set", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDescriptorWrites, object.descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkWriteDescriptorSet<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPushDescriptorSetWithTemplateInfo(const VkPushDescriptorSetWithTemplateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorUpdateTemplate<Format>(object.descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.set, settings, "uint32_t", "set", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pData, settings, "const void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePipelineProtectedAccessFeatures(const VkPhysicalDevicePipelineProtectedAccessFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineProtectedAccess, settings, "VkBool32", "pipelineProtectedAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePipelineRobustnessFeatures(const VkPhysicalDevicePipelineRobustnessFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineRobustness, settings, "VkBool32", "pipelineRobustness", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePipelineRobustnessProperties(const VkPhysicalDevicePipelineRobustnessProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessBufferBehavior<Format>(object.defaultRobustnessStorageBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessBufferBehavior<Format>(object.defaultRobustnessUniformBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessBufferBehavior<Format>(object.defaultRobustnessVertexInputs, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessVertexInputs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessImageBehavior<Format>(object.defaultRobustnessImages, settings, "VkPipelineRobustnessImageBehavior", "defaultRobustnessImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRobustnessCreateInfo(const VkPipelineRobustnessCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessBufferBehavior<Format>(object.storageBuffers, settings, "VkPipelineRobustnessBufferBehavior", "storageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessBufferBehavior<Format>(object.uniformBuffers, settings, "VkPipelineRobustnessBufferBehavior", "uniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessBufferBehavior<Format>(object.vertexInputs, settings, "VkPipelineRobustnessBufferBehavior", "vertexInputs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRobustnessImageBehavior<Format>(object.images, settings, "VkPipelineRobustnessImageBehavior", "images", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLineRasterizationFeatures(const VkPhysicalDeviceLineRasterizationFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rectangularLines, settings, "VkBool32", "rectangularLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bresenhamLines, settings, "VkBool32", "bresenhamLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.smoothLines, settings, "VkBool32", "smoothLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.stippledRectangularLines, settings, "VkBool32", "stippledRectangularLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.stippledBresenhamLines, settings, "VkBool32", "stippledBresenhamLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.stippledSmoothLines, settings, "VkBool32", "stippledSmoothLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLineRasterizationProperties(const VkPhysicalDeviceLineRasterizationProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.lineSubPixelPrecisionBits, settings, "uint32_t", "lineSubPixelPrecisionBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRasterizationLineStateCreateInfo(const VkPipelineRasterizationLineStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkLineRasterizationMode<Format>(object.lineRasterizationMode, settings, "VkLineRasterizationMode", "lineRasterizationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.stippledLineEnable, settings, "VkBool32", "stippledLineEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.lineStippleFactor, settings, "uint32_t", "lineStippleFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.lineStipplePattern, settings, "uint16_t", "lineStipplePattern", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVertexAttributeDivisorProperties(const VkPhysicalDeviceVertexAttributeDivisorProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVertexAttribDivisor, settings, "uint32_t", "maxVertexAttribDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.supportsNonZeroFirstInstance, settings, "VkBool32", "supportsNonZeroFirstInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVertexInputBindingDivisorDescription(const VkVertexInputBindingDivisorDescription& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.divisor, settings, "uint32_t", "divisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineVertexInputDivisorStateCreateInfo(const VkPipelineVertexInputDivisorStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vertexBindingDivisorCount, settings, "uint32_t", "vertexBindingDivisorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pVertexBindingDivisors, object.vertexBindingDivisorCount, settings, "const VkVertexInputBindingDivisorDescription*", "pVertexBindingDivisors", "const VkVertexInputBindingDivisorDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVertexInputBindingDivisorDescription<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVertexAttributeDivisorFeatures(const VkPhysicalDeviceVertexAttributeDivisorFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vertexAttributeInstanceRateDivisor, settings, "VkBool32", "vertexAttributeInstanceRateDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vertexAttributeInstanceRateZeroDivisor, settings, "VkBool32", "vertexAttributeInstanceRateZeroDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderingAreaInfo(const VkRenderingAreaInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewMask, settings, "uint32_t", "viewMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pColorAttachmentFormats, object.colorAttachmentCount, settings, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat<Format>);
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.depthAttachmentFormat, settings, "VkFormat", "depthAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.stencilAttachmentFormat, settings, "VkFormat", "stencilAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(const VkPhysicalDeviceDynamicRenderingLocalReadFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dynamicRenderingLocalRead, settings, "VkBool32", "dynamicRenderingLocalRead", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderingAttachmentLocationInfo(const VkRenderingAttachmentLocationInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pColorAttachmentLocations, object.colorAttachmentCount, settings, "const uint32_t*", "pColorAttachmentLocations", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderingInputAttachmentIndexInfo(const VkRenderingInputAttachmentIndexInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pColorAttachmentInputIndices, object.colorAttachmentCount, settings, "const uint32_t*", "pColorAttachmentInputIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDepthInputAttachmentIndex, settings, "const uint32_t*", "pDepthInputAttachmentIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStencilInputAttachmentIndex, settings, "const uint32_t*", "pStencilInputAttachmentIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceCapabilitiesKHR(const VkSurfaceCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.minImageCount, settings, "uint32_t", "minImageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxImageCount, settings, "uint32_t", "maxImageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.currentExtent, settings, "VkExtent2D", "currentExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.minImageExtent, settings, "VkExtent2D", "minImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxImageExtent, settings, "VkExtent2D", "maxImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxImageArrayLayers, settings, "uint32_t", "maxImageArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceTransformFlagsKHR<Format>(object.supportedTransforms, settings, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceTransformFlagBitsKHR<Format>(object.currentTransform, settings, "VkSurfaceTransformFlagBitsKHR", "currentTransform", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCompositeAlphaFlagsKHR<Format>(object.supportedCompositeAlpha, settings, "VkCompositeAlphaFlagsKHR", "supportedCompositeAlpha", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.supportedUsageFlags, settings, "VkImageUsageFlags", "supportedUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceFormatKHR(const VkSurfaceFormatKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkColorSpaceKHR<Format>(object.colorSpace, settings, "VkColorSpaceKHR", "colorSpace", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSwapchainCreateFlagsKHR<Format>(object.flags, settings, "VkSwapchainCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceKHR<Format>(object.surface, settings, "VkSurfaceKHR", "surface", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minImageCount, settings, "uint32_t", "minImageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.imageFormat, settings, "VkFormat", "imageFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkColorSpaceKHR<Format>(object.imageColorSpace, settings, "VkColorSpaceKHR", "imageColorSpace", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.imageExtent, settings, "VkExtent2D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.imageArrayLayers, settings, "uint32_t", "imageArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.imageUsage, settings, "VkImageUsageFlags", "imageUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSharingMode<Format>(object.imageSharingMode, settings, "VkSharingMode", "imageSharingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    if (object.imageSharingMode == VK_SHARING_MODE_CONCURRENT) {
        dump_pointer_array<Format>(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    } else {
        if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) {
            dump_special<Format>("UNUSED", settings, "const uint32_t*", "pQueueFamilyIndices", indents + 1);
        } else if constexpr (Format == ApiDumpFormat::Json) {
            dump_json_UNUSED(settings, "const uint32_t*", "pQueueFamilyIndices", indents + 2);
        }
    }
    dump_separate_members<Format>(settings);
    dump_VkSurfaceTransformFlagBitsKHR<Format>(object.preTransform, settings, "VkSurfaceTransformFlagBitsKHR", "preTransform", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCompositeAlphaFlagBitsKHR<Format>(object.compositeAlpha, settings, "VkCompositeAlphaFlagBitsKHR", "compositeAlpha", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentModeKHR<Format>(object.presentMode, settings, "VkPresentModeKHR", "presentMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.clipped, settings, "VkBool32", "clipped", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSwapchainKHR<Format>(object.oldSwapchain, settings, "VkSwapchainKHR", "oldSwapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentInfoKHR(const VkPresentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pWaitSemaphores, object.waitSemaphoreCount, settings, "const VkSemaphore*", "pWaitSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSwapchains, object.swapchainCount, settings, "const VkSwapchainKHR*", "pSwapchains", "const VkSwapchainKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSwapchainKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pImageIndices, object.swapchainCount, settings, "const uint32_t*", "pImageIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pResults, object.swapchainCount, settings, "VkResult*", "pResults", "VkResult", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkResult<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSwapchainKHR<Format>(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSwapchainKHR<Format>(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.imageIndex, settings, "uint32_t", "imageIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSwapchainKHR<Format>(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.timeout, settings, "uint64_t", "timeout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphore<Format>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFence<Format>(object.fence, settings, "VkFence", "fence", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceMask, settings, "uint32_t", "deviceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.presentMask, VK_MAX_DEVICE_GROUP_SIZE, settings, "uint32_t[VK_MAX_DEVICE_GROUP_SIZE]", "presentMask", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_VkDeviceGroupPresentModeFlagsKHR<Format>(object.modes, settings, "VkDeviceGroupPresentModeFlagsKHR", "modes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDeviceMasks, object.swapchainCount, settings, "const uint32_t*", "pDeviceMasks", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_VkDeviceGroupPresentModeFlagBitsKHR<Format>(object.mode, settings, "VkDeviceGroupPresentModeFlagBitsKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceGroupPresentModeFlagsKHR<Format>(object.modes, settings, "VkDeviceGroupPresentModeFlagsKHR", "modes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayModeParametersKHR(const VkDisplayModeParametersKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkExtent2D<Format>(object.visibleRegion, settings, "VkExtent2D", "visibleRegion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.refreshRate, settings, "uint32_t", "refreshRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayModeCreateFlagsKHR<Format>(object.flags, settings, "VkDisplayModeCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayModeParametersKHR<Format>(object.parameters, settings, "VkDisplayModeParametersKHR", "parameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayModePropertiesKHR(const VkDisplayModePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkDisplayModeKHR<Format>(object.displayMode, settings, "VkDisplayModeKHR", "displayMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayModeParametersKHR<Format>(object.parameters, settings, "VkDisplayModeParametersKHR", "parameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayPlaneCapabilitiesKHR(const VkDisplayPlaneCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkDisplayPlaneAlphaFlagsKHR<Format>(object.supportedAlpha, settings, "VkDisplayPlaneAlphaFlagsKHR", "supportedAlpha", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset2D<Format>(object.minSrcPosition, settings, "VkOffset2D", "minSrcPosition", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset2D<Format>(object.maxSrcPosition, settings, "VkOffset2D", "maxSrcPosition", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.minSrcExtent, settings, "VkExtent2D", "minSrcExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxSrcExtent, settings, "VkExtent2D", "maxSrcExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset2D<Format>(object.minDstPosition, settings, "VkOffset2D", "minDstPosition", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset2D<Format>(object.maxDstPosition, settings, "VkOffset2D", "maxDstPosition", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.minDstExtent, settings, "VkExtent2D", "minDstExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxDstExtent, settings, "VkExtent2D", "maxDstExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayPlanePropertiesKHR(const VkDisplayPlanePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkDisplayKHR<Format>(object.currentDisplay, settings, "VkDisplayKHR", "currentDisplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.currentStackIndex, settings, "uint32_t", "currentStackIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkDisplayKHR<Format>(object.display, settings, "VkDisplayKHR", "display", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.displayName, settings, "const char*", "displayName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.physicalDimensions, settings, "VkExtent2D", "physicalDimensions", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.physicalResolution, settings, "VkExtent2D", "physicalResolution", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceTransformFlagsKHR<Format>(object.supportedTransforms, settings, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.planeReorderPossible, settings, "VkBool32", "planeReorderPossible", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.persistentContent, settings, "VkBool32", "persistentContent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplaySurfaceCreateFlagsKHR<Format>(object.flags, settings, "VkDisplaySurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayModeKHR<Format>(object.displayMode, settings, "VkDisplayModeKHR", "displayMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.planeIndex, settings, "uint32_t", "planeIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.planeStackIndex, settings, "uint32_t", "planeStackIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceTransformFlagBitsKHR<Format>(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.globalAlpha, settings, "float", "globalAlpha", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayPlaneAlphaFlagBitsKHR<Format>(object.alphaMode, settings, "VkDisplayPlaneAlphaFlagBitsKHR", "alphaMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.imageExtent, settings, "VkExtent2D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRect2D<Format>(object.srcRect, settings, "VkRect2D", "srcRect", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRect2D<Format>(object.dstRect, settings, "VkRect2D", "dstRect", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.persistent, settings, "VkBool32", "persistent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_XLIB_KHR)
template <ApiDumpFormat Format>
void dump_VkXlibSurfaceCreateInfoKHR(const VkXlibSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkXlibSurfaceCreateFlagsKHR<Format>(object.flags, settings, "VkXlibSurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, Display*>(object.dpy, settings, "Display*", "dpy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, Window>(object.window, settings, "Window", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)
template <ApiDumpFormat Format>
void dump_VkXcbSurfaceCreateInfoKHR(const VkXcbSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkXcbSurfaceCreateFlagsKHR<Format>(object.flags, settings, "VkXcbSurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, xcb_connection_t*>(object.connection, settings, "xcb_connection_t*", "connection", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_uint64_t_as_pointer<Format>(object.window, settings, "xcb_window_t", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
template <ApiDumpFormat Format>
void dump_VkWaylandSurfaceCreateInfoKHR(const VkWaylandSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkWaylandSurfaceCreateFlagsKHR<Format>(object.flags, settings, "VkWaylandSurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, struct wl_display*>(object.display, settings, "struct wl_display*", "display", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, struct wl_surface*>(object.surface, settings, "struct wl_surface*", "surface", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
template <ApiDumpFormat Format>
void dump_VkAndroidSurfaceCreateInfoKHR(const VkAndroidSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAndroidSurfaceCreateFlagsKHR<Format>(object.flags, settings, "VkAndroidSurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, struct ANativeWindow*>(object.window, settings, "struct ANativeWindow*", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
template <ApiDumpFormat Format>
void dump_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkWin32SurfaceCreateFlagsKHR<Format>(object.flags, settings, "VkWin32SurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, HINSTANCE>(object.hinstance, settings, "HINSTANCE", "hinstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, HWND>(object.hwnd, settings, "HWND", "hwnd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR
template <ApiDumpFormat Format>
void dump_VkQueueFamilyQueryResultStatusPropertiesKHR(const VkQueueFamilyQueryResultStatusPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.queryResultStatusSupport, settings, "VkBool32", "queryResultStatusSupport", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoCodecOperationFlagsKHR<Format>(object.videoCodecOperations, settings, "VkVideoCodecOperationFlagsKHR", "videoCodecOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoProfileInfoKHR(const VkVideoProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoCodecOperationFlagBitsKHR<Format>(object.videoCodecOperation, settings, "VkVideoCodecOperationFlagBitsKHR", "videoCodecOperation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoChromaSubsamplingFlagsKHR<Format>(object.chromaSubsampling, settings, "VkVideoChromaSubsamplingFlagsKHR", "chromaSubsampling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoComponentBitDepthFlagsKHR<Format>(object.lumaBitDepth, settings, "VkVideoComponentBitDepthFlagsKHR", "lumaBitDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoComponentBitDepthFlagsKHR<Format>(object.chromaBitDepth, settings, "VkVideoComponentBitDepthFlagsKHR", "chromaBitDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoProfileListInfoKHR(const VkVideoProfileListInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.profileCount, settings, "uint32_t", "profileCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pProfiles, object.profileCount, settings, "const VkVideoProfileInfoKHR*", "pProfiles", "const VkVideoProfileInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoProfileInfoKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoCapabilityFlagsKHR<Format>(object.flags, settings, "VkVideoCapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.minBitstreamBufferOffsetAlignment, settings, "VkDeviceSize", "minBitstreamBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.minBitstreamBufferSizeAlignment, settings, "VkDeviceSize", "minBitstreamBufferSizeAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.pictureAccessGranularity, settings, "VkExtent2D", "pictureAccessGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.minCodedExtent, settings, "VkExtent2D", "minCodedExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxCodedExtent, settings, "VkExtent2D", "maxCodedExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDpbSlots, settings, "uint32_t", "maxDpbSlots", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxActiveReferencePictures, settings, "uint32_t", "maxActiveReferencePictures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtensionProperties<Format>(object.stdHeaderVersion, settings, "VkExtensionProperties", "stdHeaderVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVideoFormatInfoKHR(const VkPhysicalDeviceVideoFormatInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.imageUsage, settings, "VkImageUsageFlags", "imageUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentMapping<Format>(object.componentMapping, settings, "VkComponentMapping", "componentMapping", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageCreateFlags<Format>(object.imageCreateFlags, settings, "VkImageCreateFlags", "imageCreateFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageType<Format>(object.imageType, settings, "VkImageType", "imageType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageTiling<Format>(object.imageTiling, settings, "VkImageTiling", "imageTiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.imageUsageFlags, settings, "VkImageUsageFlags", "imageUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset2D<Format>(object.codedOffset, settings, "VkOffset2D", "codedOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.codedExtent, settings, "VkExtent2D", "codedExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageView<Format>(object.imageViewBinding, settings, "VkImageView", "imageViewBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.slotIndex, settings, "int32_t", "slotIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pPictureResource, settings, "const VkVideoPictureResourceInfoKHR*", "pPictureResource", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoPictureResourceInfoKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoSessionMemoryRequirementsKHR(const VkVideoSessionMemoryRequirementsKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryBindIndex, settings, "uint32_t", "memoryBindIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMemoryRequirements<Format>(object.memoryRequirements, settings, "VkMemoryRequirements", "memoryRequirements", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryBindIndex, settings, "uint32_t", "memoryBindIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.memorySize, settings, "VkDeviceSize", "memorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoSessionCreateFlagsKHR<Format>(object.flags, settings, "VkVideoSessionCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pVideoProfile, settings, "const VkVideoProfileInfoKHR*", "pVideoProfile", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoProfileInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.pictureFormat, settings, "VkFormat", "pictureFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxCodedExtent, settings, "VkExtent2D", "maxCodedExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.referencePictureFormat, settings, "VkFormat", "referencePictureFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDpbSlots, settings, "uint32_t", "maxDpbSlots", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxActiveReferencePictures, settings, "uint32_t", "maxActiveReferencePictures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdHeaderVersion, settings, "const VkExtensionProperties*", "pStdHeaderVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkExtensionProperties<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoSessionParametersCreateInfoKHR(const VkVideoSessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoSessionParametersCreateFlagsKHR<Format>(object.flags, settings, "VkVideoSessionParametersCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoSessionParametersKHR<Format>(object.videoSessionParametersTemplate, settings, "VkVideoSessionParametersKHR", "videoSessionParametersTemplate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoSessionKHR<Format>(object.videoSession, settings, "VkVideoSessionKHR", "videoSession", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoSessionParametersUpdateInfoKHR(const VkVideoSessionParametersUpdateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.updateSequenceCount, settings, "uint32_t", "updateSequenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoBeginCodingFlagsKHR<Format>(object.flags, settings, "VkVideoBeginCodingFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoSessionKHR<Format>(object.videoSession, settings, "VkVideoSessionKHR", "videoSession", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoSessionParametersKHR<Format>(object.videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.referenceSlotCount, settings, "uint32_t", "referenceSlotCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pReferenceSlots, object.referenceSlotCount, settings, "const VkVideoReferenceSlotInfoKHR*", "pReferenceSlots", "const VkVideoReferenceSlotInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEndCodingInfoKHR(const VkVideoEndCodingInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEndCodingFlagsKHR<Format>(object.flags, settings, "VkVideoEndCodingFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoCodingControlFlagsKHR<Format>(object.flags, settings, "VkVideoCodingControlFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoDecodeCapabilityFlagsKHR<Format>(object.flags, settings, "VkVideoDecodeCapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoDecodeUsageFlagsKHR<Format>(object.videoUsageHints, settings, "VkVideoDecodeUsageFlagsKHR", "videoUsageHints", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoDecodeFlagsKHR<Format>(object.flags, settings, "VkVideoDecodeFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.srcBuffer, settings, "VkBuffer", "srcBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.srcBufferOffset, settings, "VkDeviceSize", "srcBufferOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.srcBufferRange, settings, "VkDeviceSize", "srcBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoPictureResourceInfoKHR<Format>(object.dstPictureResource, settings, "VkVideoPictureResourceInfoKHR", "dstPictureResource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSetupReferenceSlot, settings, "const VkVideoReferenceSlotInfoKHR*", "pSetupReferenceSlot", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.referenceSlotCount, settings, "uint32_t", "referenceSlotCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pReferenceSlots, object.referenceSlotCount, settings, "const VkVideoReferenceSlotInfoKHR*", "pReferenceSlots", "const VkVideoReferenceSlotInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264CapabilitiesKHR(const VkVideoEncodeH264CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH264CapabilityFlagsKHR<Format>(object.flags, settings, "VkVideoEncodeH264CapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264LevelIdc<Format>(object.maxLevelIdc, settings, "StdVideoH264LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSliceCount, settings, "uint32_t", "maxSliceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPPictureL0ReferenceCount, settings, "uint32_t", "maxPPictureL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxBPictureL0ReferenceCount, settings, "uint32_t", "maxBPictureL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxL1ReferenceCount, settings, "uint32_t", "maxL1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTemporalLayerCount, settings, "uint32_t", "maxTemporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.expectDyadicTemporalLayerPattern, settings, "VkBool32", "expectDyadicTemporalLayerPattern", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.minQp, settings, "int32_t", "minQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.maxQp, settings, "int32_t", "maxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.prefersGopRemainingFrames, settings, "VkBool32", "prefersGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.requiresGopRemainingFrames, settings, "VkBool32", "requiresGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH264StdFlagsKHR<Format>(object.stdSyntaxFlags, settings, "VkVideoEncodeH264StdFlagsKHR", "stdSyntaxFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264QpKHR(const VkVideoEncodeH264QpKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, int32_t>(object.qpI, settings, "int32_t", "qpI", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.qpP, settings, "int32_t", "qpP", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.qpB, settings, "int32_t", "qpB", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264QualityLevelPropertiesKHR(const VkVideoEncodeH264QualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH264RateControlFlagsKHR<Format>(object.preferredRateControlFlags, settings, "VkVideoEncodeH264RateControlFlagsKHR", "preferredRateControlFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredGopFrameCount, settings, "uint32_t", "preferredGopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredIdrPeriod, settings, "uint32_t", "preferredIdrPeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredConsecutiveBFrameCount, settings, "uint32_t", "preferredConsecutiveBFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredTemporalLayerCount, settings, "uint32_t", "preferredTemporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH264QpKHR<Format>(object.preferredConstantQp, settings, "VkVideoEncodeH264QpKHR", "preferredConstantQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredMaxL0ReferenceCount, settings, "uint32_t", "preferredMaxL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredMaxL1ReferenceCount, settings, "uint32_t", "preferredMaxL1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.preferredStdEntropyCodingModeFlag, settings, "VkBool32", "preferredStdEntropyCodingModeFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264SessionCreateInfoKHR(const VkVideoEncodeH264SessionCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMaxLevelIdc, settings, "VkBool32", "useMaxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264LevelIdc<Format>(object.maxLevelIdc, settings, "StdVideoH264LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264SessionParametersAddInfoKHR(const VkVideoEncodeH264SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH264SequenceParameterSet*", "pStdSPSs", "const StdVideoH264SequenceParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSet<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH264PictureParameterSet*", "pStdPPSs", "const StdVideoH264PictureParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264PictureParameterSet<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264SessionParametersCreateInfoKHR(const VkVideoEncodeH264SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pParametersAddInfo, settings, "const VkVideoEncodeH264SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH264SessionParametersAddInfoKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264SessionParametersGetInfoKHR(const VkVideoEncodeH264SessionParametersGetInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.writeStdSPS, settings, "VkBool32", "writeStdSPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.writeStdPPS, settings, "VkBool32", "writeStdPPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdSPSId, settings, "uint32_t", "stdSPSId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdPPSId, settings, "uint32_t", "stdPPSId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(const VkVideoEncodeH264SessionParametersFeedbackInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hasStdSPSOverrides, settings, "VkBool32", "hasStdSPSOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hasStdPPSOverrides, settings, "VkBool32", "hasStdPPSOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264NaluSliceInfoKHR(const VkVideoEncodeH264NaluSliceInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.constantQp, settings, "int32_t", "constantQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdSliceHeader, settings, "const StdVideoEncodeH264SliceHeader*", "pStdSliceHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264SliceHeader<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264PictureInfoKHR(const VkVideoEncodeH264PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.naluSliceEntryCount, settings, "uint32_t", "naluSliceEntryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pNaluSliceEntries, object.naluSliceEntryCount, settings, "const VkVideoEncodeH264NaluSliceInfoKHR*", "pNaluSliceEntries", "const VkVideoEncodeH264NaluSliceInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH264NaluSliceInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdPictureInfo, settings, "const StdVideoEncodeH264PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264PictureInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.generatePrefixNalu, settings, "VkBool32", "generatePrefixNalu", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264DpbSlotInfoKHR(const VkVideoEncodeH264DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdReferenceInfo, settings, "const StdVideoEncodeH264ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264ReferenceInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264ProfileInfoKHR(const VkVideoEncodeH264ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264ProfileIdc<Format>(object.stdProfileIdc, settings, "StdVideoH264ProfileIdc", "stdProfileIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264RateControlInfoKHR(const VkVideoEncodeH264RateControlInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH264RateControlFlagsKHR<Format>(object.flags, settings, "VkVideoEncodeH264RateControlFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopFrameCount, settings, "uint32_t", "gopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.idrPeriod, settings, "uint32_t", "idrPeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.consecutiveBFrameCount, settings, "uint32_t", "consecutiveBFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.temporalLayerCount, settings, "uint32_t", "temporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264FrameSizeKHR(const VkVideoEncodeH264FrameSizeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.frameISize, settings, "uint32_t", "frameISize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.framePSize, settings, "uint32_t", "framePSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frameBSize, settings, "uint32_t", "frameBSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264RateControlLayerInfoKHR(const VkVideoEncodeH264RateControlLayerInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMinQp, settings, "VkBool32", "useMinQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH264QpKHR<Format>(object.minQp, settings, "VkVideoEncodeH264QpKHR", "minQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMaxQp, settings, "VkBool32", "useMaxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH264QpKHR<Format>(object.maxQp, settings, "VkVideoEncodeH264QpKHR", "maxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMaxFrameSize, settings, "VkBool32", "useMaxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH264FrameSizeKHR<Format>(object.maxFrameSize, settings, "VkVideoEncodeH264FrameSizeKHR", "maxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264GopRemainingFrameInfoKHR(const VkVideoEncodeH264GopRemainingFrameInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useGopRemainingFrames, settings, "VkBool32", "useGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopRemainingI, settings, "uint32_t", "gopRemainingI", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopRemainingP, settings, "uint32_t", "gopRemainingP", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopRemainingB, settings, "uint32_t", "gopRemainingB", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265CapabilitiesKHR(const VkVideoEncodeH265CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH265CapabilityFlagsKHR<Format>(object.flags, settings, "VkVideoEncodeH265CapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265LevelIdc<Format>(object.maxLevelIdc, settings, "StdVideoH265LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSliceSegmentCount, settings, "uint32_t", "maxSliceSegmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxTiles, settings, "VkExtent2D", "maxTiles", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH265CtbSizeFlagsKHR<Format>(object.ctbSizes, settings, "VkVideoEncodeH265CtbSizeFlagsKHR", "ctbSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH265TransformBlockSizeFlagsKHR<Format>(object.transformBlockSizes, settings, "VkVideoEncodeH265TransformBlockSizeFlagsKHR", "transformBlockSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPPictureL0ReferenceCount, settings, "uint32_t", "maxPPictureL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxBPictureL0ReferenceCount, settings, "uint32_t", "maxBPictureL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxL1ReferenceCount, settings, "uint32_t", "maxL1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSubLayerCount, settings, "uint32_t", "maxSubLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.expectDyadicTemporalSubLayerPattern, settings, "VkBool32", "expectDyadicTemporalSubLayerPattern", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.minQp, settings, "int32_t", "minQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.maxQp, settings, "int32_t", "maxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.prefersGopRemainingFrames, settings, "VkBool32", "prefersGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.requiresGopRemainingFrames, settings, "VkBool32", "requiresGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH265StdFlagsKHR<Format>(object.stdSyntaxFlags, settings, "VkVideoEncodeH265StdFlagsKHR", "stdSyntaxFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265SessionCreateInfoKHR(const VkVideoEncodeH265SessionCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMaxLevelIdc, settings, "VkBool32", "useMaxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265LevelIdc<Format>(object.maxLevelIdc, settings, "StdVideoH265LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265QpKHR(const VkVideoEncodeH265QpKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, int32_t>(object.qpI, settings, "int32_t", "qpI", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.qpP, settings, "int32_t", "qpP", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.qpB, settings, "int32_t", "qpB", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265QualityLevelPropertiesKHR(const VkVideoEncodeH265QualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH265RateControlFlagsKHR<Format>(object.preferredRateControlFlags, settings, "VkVideoEncodeH265RateControlFlagsKHR", "preferredRateControlFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredGopFrameCount, settings, "uint32_t", "preferredGopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredIdrPeriod, settings, "uint32_t", "preferredIdrPeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredConsecutiveBFrameCount, settings, "uint32_t", "preferredConsecutiveBFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredSubLayerCount, settings, "uint32_t", "preferredSubLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH265QpKHR<Format>(object.preferredConstantQp, settings, "VkVideoEncodeH265QpKHR", "preferredConstantQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredMaxL0ReferenceCount, settings, "uint32_t", "preferredMaxL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredMaxL1ReferenceCount, settings, "uint32_t", "preferredMaxL1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265SessionParametersAddInfoKHR(const VkVideoEncodeH265SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdVPSCount, settings, "uint32_t", "stdVPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStdVPSs, object.stdVPSCount, settings, "const StdVideoH265VideoParameterSet*", "pStdVPSs", "const StdVideoH265VideoParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265VideoParameterSet<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH265SequenceParameterSet*", "pStdSPSs", "const StdVideoH265SequenceParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSet<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH265PictureParameterSet*", "pStdPPSs", "const StdVideoH265PictureParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PictureParameterSet<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265SessionParametersCreateInfoKHR(const VkVideoEncodeH265SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStdVPSCount, settings, "uint32_t", "maxStdVPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pParametersAddInfo, settings, "const VkVideoEncodeH265SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH265SessionParametersAddInfoKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265SessionParametersGetInfoKHR(const VkVideoEncodeH265SessionParametersGetInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.writeStdVPS, settings, "VkBool32", "writeStdVPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.writeStdSPS, settings, "VkBool32", "writeStdSPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.writeStdPPS, settings, "VkBool32", "writeStdPPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdVPSId, settings, "uint32_t", "stdVPSId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdSPSId, settings, "uint32_t", "stdSPSId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdPPSId, settings, "uint32_t", "stdPPSId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(const VkVideoEncodeH265SessionParametersFeedbackInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hasStdVPSOverrides, settings, "VkBool32", "hasStdVPSOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hasStdSPSOverrides, settings, "VkBool32", "hasStdSPSOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hasStdPPSOverrides, settings, "VkBool32", "hasStdPPSOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265NaluSliceSegmentInfoKHR(const VkVideoEncodeH265NaluSliceSegmentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.constantQp, settings, "int32_t", "constantQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdSliceSegmentHeader, settings, "const StdVideoEncodeH265SliceSegmentHeader*", "pStdSliceSegmentHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265SliceSegmentHeader<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265PictureInfoKHR(const VkVideoEncodeH265PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.naluSliceSegmentEntryCount, settings, "uint32_t", "naluSliceSegmentEntryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pNaluSliceSegmentEntries, object.naluSliceSegmentEntryCount, settings, "const VkVideoEncodeH265NaluSliceSegmentInfoKHR*", "pNaluSliceSegmentEntries", "const VkVideoEncodeH265NaluSliceSegmentInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH265NaluSliceSegmentInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdPictureInfo, settings, "const StdVideoEncodeH265PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265PictureInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265DpbSlotInfoKHR(const VkVideoEncodeH265DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdReferenceInfo, settings, "const StdVideoEncodeH265ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265ReferenceInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265ProfileInfoKHR(const VkVideoEncodeH265ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265ProfileIdc<Format>(object.stdProfileIdc, settings, "StdVideoH265ProfileIdc", "stdProfileIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265RateControlInfoKHR(const VkVideoEncodeH265RateControlInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH265RateControlFlagsKHR<Format>(object.flags, settings, "VkVideoEncodeH265RateControlFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopFrameCount, settings, "uint32_t", "gopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.idrPeriod, settings, "uint32_t", "idrPeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.consecutiveBFrameCount, settings, "uint32_t", "consecutiveBFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subLayerCount, settings, "uint32_t", "subLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265FrameSizeKHR(const VkVideoEncodeH265FrameSizeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.frameISize, settings, "uint32_t", "frameISize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.framePSize, settings, "uint32_t", "framePSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frameBSize, settings, "uint32_t", "frameBSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265RateControlLayerInfoKHR(const VkVideoEncodeH265RateControlLayerInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMinQp, settings, "VkBool32", "useMinQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH265QpKHR<Format>(object.minQp, settings, "VkVideoEncodeH265QpKHR", "minQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMaxQp, settings, "VkBool32", "useMaxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH265QpKHR<Format>(object.maxQp, settings, "VkVideoEncodeH265QpKHR", "maxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMaxFrameSize, settings, "VkBool32", "useMaxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH265FrameSizeKHR<Format>(object.maxFrameSize, settings, "VkVideoEncodeH265FrameSizeKHR", "maxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265GopRemainingFrameInfoKHR(const VkVideoEncodeH265GopRemainingFrameInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useGopRemainingFrames, settings, "VkBool32", "useGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopRemainingI, settings, "uint32_t", "gopRemainingI", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopRemainingP, settings, "uint32_t", "gopRemainingP", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopRemainingB, settings, "uint32_t", "gopRemainingB", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264ProfileIdc<Format>(object.stdProfileIdc, settings, "StdVideoH264ProfileIdc", "stdProfileIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoDecodeH264PictureLayoutFlagBitsKHR<Format>(object.pictureLayout, settings, "VkVideoDecodeH264PictureLayoutFlagBitsKHR", "pictureLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH264LevelIdc<Format>(object.maxLevelIdc, settings, "StdVideoH264LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset2D<Format>(object.fieldOffsetGranularity, settings, "VkOffset2D", "fieldOffsetGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH264SessionParametersAddInfoKHR(const VkVideoDecodeH264SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH264SequenceParameterSet*", "pStdSPSs", "const StdVideoH264SequenceParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSet<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH264PictureParameterSet*", "pStdPPSs", "const StdVideoH264PictureParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264PictureParameterSet<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH264SessionParametersCreateInfoKHR(const VkVideoDecodeH264SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pParametersAddInfo, settings, "const VkVideoDecodeH264SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoDecodeH264SessionParametersAddInfoKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdPictureInfo, settings, "const StdVideoDecodeH264PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH264PictureInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sliceCount, settings, "uint32_t", "sliceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSliceOffsets, object.sliceCount, settings, "const uint32_t*", "pSliceOffsets", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdReferenceInfo, settings, "const StdVideoDecodeH264ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH264ReferenceInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
template <ApiDumpFormat Format>
void dump_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, HANDLE>(object.handle, settings, "HANDLE", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const SECURITY_ATTRIBUTES*>(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, DWORD>(object.dwAccess, settings, "DWORD", "dwAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR
template <ApiDumpFormat Format>
void dump_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int>(object.fd, settings, "int", "fd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
template <ApiDumpFormat Format>
void dump_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.acquireCount, settings, "uint32_t", "acquireCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAcquireSyncs, object.acquireCount, settings, "const VkDeviceMemory*", "pAcquireSyncs", "const VkDeviceMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAcquireKeys, object.acquireCount, settings, "const uint64_t*", "pAcquireKeys", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAcquireTimeouts, object.acquireCount, settings, "const uint32_t*", "pAcquireTimeouts", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.releaseCount, settings, "uint32_t", "releaseCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pReleaseSyncs, object.releaseCount, settings, "const VkDeviceMemory*", "pReleaseSyncs", "const VkDeviceMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pReleaseKeys, object.releaseCount, settings, "const uint64_t*", "pReleaseKeys", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphore<Format>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphoreImportFlags<Format>(object.flags, settings, "VkSemaphoreImportFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, HANDLE>(object.handle, settings, "HANDLE", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const SECURITY_ATTRIBUTES*>(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, DWORD>(object.dwAccess, settings, "DWORD", "dwAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.waitSemaphoreValuesCount, settings, "uint32_t", "waitSemaphoreValuesCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pWaitSemaphoreValues, object.waitSemaphoreValuesCount, settings, "const uint64_t*", "pWaitSemaphoreValues", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.signalSemaphoreValuesCount, settings, "uint32_t", "signalSemaphoreValuesCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSignalSemaphoreValues, object.signalSemaphoreValuesCount, settings, "const uint64_t*", "pSignalSemaphoreValues", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphore<Format>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR
template <ApiDumpFormat Format>
void dump_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphore<Format>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphoreImportFlags<Format>(object.flags, settings, "VkSemaphoreImportFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int>(object.fd, settings, "int", "fd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphore<Format>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRectLayerKHR(const VkRectLayerKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkOffset2D<Format>(object.offset, settings, "VkOffset2D", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.extent, settings, "VkExtent2D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.layer, settings, "uint32_t", "layer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentRegionKHR(const VkPresentRegionKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.rectangleCount, settings, "uint32_t", "rectangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRectangles, object.rectangleCount, settings, "const VkRectLayerKHR*", "pRectangles", "const VkRectLayerKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRectLayerKHR<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentRegionsKHR(const VkPresentRegionsKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.swapchainCount, settings, "const VkPresentRegionKHR*", "pRegions", "const VkPresentRegionKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentRegionKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.sharedPresentSupportedUsageFlags, settings, "VkImageUsageFlags", "sharedPresentSupportedUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
template <ApiDumpFormat Format>
void dump_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFence<Format>(object.fence, settings, "VkFence", "fence", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFenceImportFlags<Format>(object.flags, settings, "VkFenceImportFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalFenceHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, HANDLE>(object.handle, settings, "HANDLE", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const SECURITY_ATTRIBUTES*>(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, DWORD>(object.dwAccess, settings, "DWORD", "dwAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFence<Format>(object.fence, settings, "VkFence", "fence", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalFenceHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR
template <ApiDumpFormat Format>
void dump_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFence<Format>(object.fence, settings, "VkFence", "fence", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFenceImportFlags<Format>(object.flags, settings, "VkFenceImportFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalFenceHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int>(object.fd, settings, "int", "fd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFence<Format>(object.fence, settings, "VkFence", "fence", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalFenceHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.performanceCounterQueryPools, settings, "VkBool32", "performanceCounterQueryPools", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.performanceCounterMultipleQueryPools, settings, "VkBool32", "performanceCounterMultipleQueryPools", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.allowCommandBufferQueryCopies, settings, "VkBool32", "allowCommandBufferQueryCopies", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceCounterKHR(const VkPerformanceCounterKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPerformanceCounterUnitKHR<Format>(object.unit, settings, "VkPerformanceCounterUnitKHR", "unit", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPerformanceCounterScopeKHR<Format>(object.scope, settings, "VkPerformanceCounterScopeKHR", "scope", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPerformanceCounterStorageKHR<Format>(object.storage, settings, "VkPerformanceCounterStorageKHR", "storage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.uuid, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "uuid", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPerformanceCounterDescriptionFlagsKHR<Format>(object.flags, settings, "VkPerformanceCounterDescriptionFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.category, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "category", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.counterIndexCount, settings, "uint32_t", "counterIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCounterIndices, object.counterIndexCount, settings, "const uint32_t*", "pCounterIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceCounterResultKHR(const VkPerformanceCounterResultKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    dump_type<Format, int32_t>(object.int32, settings, "int32_t", "int32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int64_t>(object.int64, settings, "int64_t", "int64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.uint32, settings, "uint32_t", "uint32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.uint64, settings, "uint64_t", "uint64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.float32, settings, "float", "float32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, double>(object.float64, settings, "double", "float64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAcquireProfilingLockFlagsKHR<Format>(object.flags, settings, "VkAcquireProfilingLockFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.timeout, settings, "uint64_t", "timeout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.counterPassIndex, settings, "uint32_t", "counterPassIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceKHR<Format>(object.surface, settings, "VkSurfaceKHR", "surface", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceCapabilitiesKHR<Format>(object.surfaceCapabilities, settings, "VkSurfaceCapabilitiesKHR", "surfaceCapabilities", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceFormatKHR<Format>(object.surfaceFormat, settings, "VkSurfaceFormatKHR", "surfaceFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayProperties2KHR(const VkDisplayProperties2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayPropertiesKHR<Format>(object.displayProperties, settings, "VkDisplayPropertiesKHR", "displayProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayPlanePropertiesKHR<Format>(object.displayPlaneProperties, settings, "VkDisplayPlanePropertiesKHR", "displayPlaneProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayModePropertiesKHR<Format>(object.displayModeProperties, settings, "VkDisplayModePropertiesKHR", "displayModeProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayModeKHR<Format>(object.mode, settings, "VkDisplayModeKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.planeIndex, settings, "uint32_t", "planeIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayPlaneCapabilitiesKHR<Format>(object.capabilities, settings, "VkDisplayPlaneCapabilitiesKHR", "capabilities", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderBfloat16FeaturesKHR(const VkPhysicalDeviceShaderBfloat16FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBFloat16Type, settings, "VkBool32", "shaderBFloat16Type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBFloat16DotProduct, settings, "VkBool32", "shaderBFloat16DotProduct", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBFloat16CooperativeMatrix, settings, "VkBool32", "shaderBFloat16CooperativeMatrix", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const VkPhysicalDevicePortabilitySubsetFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.constantAlphaColorBlendFactors, settings, "VkBool32", "constantAlphaColorBlendFactors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.events, settings, "VkBool32", "events", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imageViewFormatReinterpretation, settings, "VkBool32", "imageViewFormatReinterpretation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imageViewFormatSwizzle, settings, "VkBool32", "imageViewFormatSwizzle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imageView2DOn3DImage, settings, "VkBool32", "imageView2DOn3DImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multisampleArrayImage, settings, "VkBool32", "multisampleArrayImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.mutableComparisonSamplers, settings, "VkBool32", "mutableComparisonSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pointPolygons, settings, "VkBool32", "pointPolygons", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.samplerMipLodBias, settings, "VkBool32", "samplerMipLodBias", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.separateStencilMaskRef, settings, "VkBool32", "separateStencilMaskRef", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSampleRateInterpolationFunctions, settings, "VkBool32", "shaderSampleRateInterpolationFunctions", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tessellationIsolines, settings, "VkBool32", "tessellationIsolines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tessellationPointMode, settings, "VkBool32", "tessellationPointMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.triangleFans, settings, "VkBool32", "triangleFans", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vertexAttributeAccessBeyondStride, settings, "VkBool32", "vertexAttributeAccessBeyondStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const VkPhysicalDevicePortabilitySubsetPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minVertexInputBindingStrideAlignment, settings, "uint32_t", "minVertexInputBindingStrideAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_ENABLE_BETA_EXTENSIONS
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSubgroupClock, settings, "VkBool32", "shaderSubgroupClock", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderDeviceClock, settings, "VkBool32", "shaderDeviceClock", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265ProfileIdc<Format>(object.stdProfileIdc, settings, "StdVideoH265ProfileIdc", "stdProfileIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoH265LevelIdc<Format>(object.maxLevelIdc, settings, "StdVideoH265LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH265SessionParametersAddInfoKHR(const VkVideoDecodeH265SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdVPSCount, settings, "uint32_t", "stdVPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStdVPSs, object.stdVPSCount, settings, "const StdVideoH265VideoParameterSet*", "pStdVPSs", "const StdVideoH265VideoParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265VideoParameterSet<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH265SequenceParameterSet*", "pStdSPSs", "const StdVideoH265SequenceParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSet<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH265PictureParameterSet*", "pStdPPSs", "const StdVideoH265PictureParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PictureParameterSet<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH265SessionParametersCreateInfoKHR(const VkVideoDecodeH265SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStdVPSCount, settings, "uint32_t", "maxStdVPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pParametersAddInfo, settings, "const VkVideoDecodeH265SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoDecodeH265SessionParametersAddInfoKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdPictureInfo, settings, "const StdVideoDecodeH265PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH265PictureInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sliceSegmentCount, settings, "uint32_t", "sliceSegmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSliceSegmentOffsets, object.sliceSegmentCount, settings, "const uint32_t*", "pSliceSegmentOffsets", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdReferenceInfo, settings, "const StdVideoDecodeH265ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH265ReferenceInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pFragmentShadingRateAttachment, settings, "const VkAttachmentReference2*", "pFragmentShadingRateAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2<Format>);
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.shadingRateAttachmentTexelSize, settings, "VkExtent2D", "shadingRateAttachmentTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.fragmentSize, settings, "VkExtent2D", "fragmentSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.combinerOps, 2, settings, "VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "VkFragmentShadingRateCombinerOpKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFragmentShadingRateCombinerOpKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineFragmentShadingRate, settings, "VkBool32", "pipelineFragmentShadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primitiveFragmentShadingRate, settings, "VkBool32", "primitiveFragmentShadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.attachmentFragmentShadingRate, settings, "VkBool32", "attachmentFragmentShadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.minFragmentShadingRateAttachmentTexelSize, settings, "VkExtent2D", "minFragmentShadingRateAttachmentTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxFragmentShadingRateAttachmentTexelSize, settings, "VkExtent2D", "maxFragmentShadingRateAttachmentTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFragmentShadingRateAttachmentTexelSizeAspectRatio, settings, "uint32_t", "maxFragmentShadingRateAttachmentTexelSizeAspectRatio", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primitiveFragmentShadingRateWithMultipleViewports, settings, "VkBool32", "primitiveFragmentShadingRateWithMultipleViewports", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.layeredShadingRateAttachments, settings, "VkBool32", "layeredShadingRateAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShadingRateNonTrivialCombinerOps, settings, "VkBool32", "fragmentShadingRateNonTrivialCombinerOps", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxFragmentSize, settings, "VkExtent2D", "maxFragmentSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFragmentSizeAspectRatio, settings, "uint32_t", "maxFragmentSizeAspectRatio", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFragmentShadingRateCoverageSamples, settings, "uint32_t", "maxFragmentShadingRateCoverageSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.maxFragmentShadingRateRasterizationSamples, settings, "VkSampleCountFlagBits", "maxFragmentShadingRateRasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShadingRateWithShaderDepthStencilWrites, settings, "VkBool32", "fragmentShadingRateWithShaderDepthStencilWrites", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShadingRateWithSampleMask, settings, "VkBool32", "fragmentShadingRateWithSampleMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShadingRateWithShaderSampleMask, settings, "VkBool32", "fragmentShadingRateWithShaderSampleMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShadingRateWithConservativeRasterization, settings, "VkBool32", "fragmentShadingRateWithConservativeRasterization", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShadingRateWithFragmentShaderInterlock, settings, "VkBool32", "fragmentShadingRateWithFragmentShaderInterlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShadingRateWithCustomSampleLocations, settings, "VkBool32", "fragmentShadingRateWithCustomSampleLocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShadingRateStrictMultiplyCombiner, settings, "VkBool32", "fragmentShadingRateStrictMultiplyCombiner", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.sampleCounts, settings, "VkSampleCountFlags", "sampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.fragmentSize, settings, "VkExtent2D", "fragmentSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderingFragmentShadingRateAttachmentInfoKHR(const VkRenderingFragmentShadingRateAttachmentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageView<Format>(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.shadingRateAttachmentTexelSize, settings, "VkExtent2D", "shadingRateAttachmentTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderConstantDataFeaturesKHR(const VkPhysicalDeviceShaderConstantDataFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderConstantData, settings, "VkBool32", "shaderConstantData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderAbortFeaturesKHR(const VkPhysicalDeviceShaderAbortFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderAbort, settings, "VkBool32", "shaderAbort", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceFaultShaderAbortMessageInfoKHR(const VkDeviceFaultShaderAbortMessageInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.messageDataSize, settings, "uint64_t", "messageDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pMessageData, settings, "void*", "pMessageData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderAbortPropertiesKHR(const VkPhysicalDeviceShaderAbortPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxShaderAbortMessageSize, settings, "uint64_t", "maxShaderAbortMessageSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderQuadControlFeaturesKHR(const VkPhysicalDeviceShaderQuadControlFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderQuadControl, settings, "VkBool32", "shaderQuadControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.supportsProtected, settings, "VkBool32", "supportsProtected", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePresentWaitFeaturesKHR(const VkPhysicalDevicePresentWaitFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentWait, settings, "VkBool32", "presentWait", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineExecutableInfo, settings, "VkBool32", "pipelineExecutableInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineInfoKHR(const VkPipelineInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.stages, settings, "VkShaderStageFlags", "stages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subgroupSize, settings, "uint32_t", "subgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.executableIndex, settings, "uint32_t", "executableIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineExecutableStatisticValueKHR(const VkPipelineExecutableStatisticValueKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    dump_type<Format, VkBool32>(object.b32, settings, "VkBool32", "b32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int64_t>(object.i64, settings, "int64_t", "i64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.u64, settings, "uint64_t", "u64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, double>(object.f64, settings, "double", "f64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineExecutableStatisticFormatKHR<Format>(object.format, settings, "VkPipelineExecutableStatisticFormatKHR", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineExecutableStatisticValueKHR<Format>(object.value, settings, "VkPipelineExecutableStatisticValueKHR", "value", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.isText, settings, "VkBool32", "isText", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pData, settings, "void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.libraryCount, settings, "uint32_t", "libraryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pLibraries, object.libraryCount, settings, "const VkPipeline*", "pLibraries", "const VkPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipeline<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentIdKHR(const VkPresentIdKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPresentIds, object.swapchainCount, settings, "const uint64_t*", "pPresentIds", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePresentIdFeaturesKHR(const VkPhysicalDevicePresentIdFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentId, settings, "VkBool32", "presentId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeFlagsKHR<Format>(object.flags, settings, "VkVideoEncodeFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.dstBuffer, settings, "VkBuffer", "dstBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.dstBufferOffset, settings, "VkDeviceSize", "dstBufferOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.dstBufferRange, settings, "VkDeviceSize", "dstBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoPictureResourceInfoKHR<Format>(object.srcPictureResource, settings, "VkVideoPictureResourceInfoKHR", "srcPictureResource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSetupReferenceSlot, settings, "const VkVideoReferenceSlotInfoKHR*", "pSetupReferenceSlot", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.referenceSlotCount, settings, "uint32_t", "referenceSlotCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pReferenceSlots, object.referenceSlotCount, settings, "const VkVideoReferenceSlotInfoKHR*", "pReferenceSlots", "const VkVideoReferenceSlotInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.precedingExternallyEncodedBytes, settings, "uint32_t", "precedingExternallyEncodedBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeCapabilityFlagsKHR<Format>(object.flags, settings, "VkVideoEncodeCapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRateControlModeFlagsKHR<Format>(object.rateControlModes, settings, "VkVideoEncodeRateControlModeFlagsKHR", "rateControlModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxRateControlLayers, settings, "uint32_t", "maxRateControlLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxBitrate, settings, "uint64_t", "maxBitrate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxQualityLevels, settings, "uint32_t", "maxQualityLevels", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.encodeInputPictureGranularity, settings, "VkExtent2D", "encodeInputPictureGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeFeedbackFlagsKHR<Format>(object.supportedEncodeFeedbackFlags, settings, "VkVideoEncodeFeedbackFlagsKHR", "supportedEncodeFeedbackFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeFeedbackFlagsKHR<Format>(object.encodeFeedbackFlags, settings, "VkVideoEncodeFeedbackFlagsKHR", "encodeFeedbackFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeUsageFlagsKHR<Format>(object.videoUsageHints, settings, "VkVideoEncodeUsageFlagsKHR", "videoUsageHints", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeContentFlagsKHR<Format>(object.videoContentHints, settings, "VkVideoEncodeContentFlagsKHR", "videoContentHints", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeTuningModeKHR<Format>(object.tuningMode, settings, "VkVideoEncodeTuningModeKHR", "tuningMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeRateControlLayerInfoKHR(const VkVideoEncodeRateControlLayerInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.averageBitrate, settings, "uint64_t", "averageBitrate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxBitrate, settings, "uint64_t", "maxBitrate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frameRateNumerator, settings, "uint32_t", "frameRateNumerator", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frameRateDenominator, settings, "uint32_t", "frameRateDenominator", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRateControlFlagsKHR<Format>(object.flags, settings, "VkVideoEncodeRateControlFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRateControlModeFlagBitsKHR<Format>(object.rateControlMode, settings, "VkVideoEncodeRateControlModeFlagBitsKHR", "rateControlMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pLayers, object.layerCount, settings, "const VkVideoEncodeRateControlLayerInfoKHR*", "pLayers", "const VkVideoEncodeRateControlLayerInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeRateControlLayerInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.virtualBufferSizeInMs, settings, "uint32_t", "virtualBufferSizeInMs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.initialVirtualBufferSizeInMs, settings, "uint32_t", "initialVirtualBufferSizeInMs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pVideoProfile, settings, "const VkVideoProfileInfoKHR*", "pVideoProfile", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoProfileInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.qualityLevel, settings, "uint32_t", "qualityLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeQualityLevelPropertiesKHR(const VkVideoEncodeQualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRateControlModeFlagBitsKHR<Format>(object.preferredRateControlMode, settings, "VkVideoEncodeRateControlModeFlagBitsKHR", "preferredRateControlMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredRateControlLayerCount, settings, "uint32_t", "preferredRateControlLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeQualityLevelInfoKHR(const VkVideoEncodeQualityLevelInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.qualityLevel, settings, "uint32_t", "qualityLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeSessionParametersGetInfoKHR(const VkVideoEncodeSessionParametersGetInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoSessionParametersKHR<Format>(object.videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeSessionParametersFeedbackInfoKHR(const VkVideoEncodeSessionParametersFeedbackInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hasOverrides, settings, "VkBool32", "hasOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceAddressRangeKHR(const VkDeviceAddressRangeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.address, settings, "VkDeviceAddress", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkStridedDeviceAddressRangeKHR(const VkStridedDeviceAddressRangeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.address, settings, "VkDeviceAddress", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.stride, settings, "VkDeviceSize", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceMemoryCopyKHR(const VkDeviceMemoryCopyKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.srcRange, settings, "VkDeviceAddressRangeKHR", "srcRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.srcFlags, settings, "VkAddressCommandFlagsKHR", "srcFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.dstRange, settings, "VkDeviceAddressRangeKHR", "dstRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.dstFlags, settings, "VkAddressCommandFlagsKHR", "dstFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyDeviceMemoryInfoKHR(const VkCopyDeviceMemoryInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkDeviceMemoryCopyKHR*", "pRegions", "const VkDeviceMemoryCopyKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemoryCopyKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceMemoryImageCopyKHR(const VkDeviceMemoryImageCopyKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.addressRange, settings, "VkDeviceAddressRangeKHR", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.addressFlags, settings, "VkAddressCommandFlagsKHR", "addressFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.addressRowLength, settings, "uint32_t", "addressRowLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.addressImageHeight, settings, "uint32_t", "addressImageHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyDeviceMemoryImageInfoKHR(const VkCopyDeviceMemoryImageInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkDeviceMemoryImageCopyKHR*", "pRegions", "const VkDeviceMemoryImageCopyKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemoryImageCopyKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryRangeBarrierKHR(const VkMemoryRangeBarrierKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags2<Format>(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags2<Format>(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.addressRange, settings, "VkDeviceAddressRangeKHR", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.addressFlags, settings, "VkAddressCommandFlagsKHR", "addressFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryRangeBarriersInfoKHR(const VkMemoryRangeBarriersInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryRangeBarrierCount, settings, "uint32_t", "memoryRangeBarrierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pMemoryRangeBarriers, object.memoryRangeBarrierCount, settings, "const VkMemoryRangeBarrierKHR*", "pMemoryRangeBarriers", "const VkMemoryRangeBarrierKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryRangeBarrierKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR(const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceAddressCommands, settings, "VkBool32", "deviceAddressCommands", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindIndexBuffer3InfoKHR(const VkBindIndexBuffer3InfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.addressRange, settings, "VkDeviceAddressRangeKHR", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.addressFlags, settings, "VkAddressCommandFlagsKHR", "addressFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndexType<Format>(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindVertexBuffer3InfoKHR(const VkBindVertexBuffer3InfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.setStride, settings, "VkBool32", "setStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStridedDeviceAddressRangeKHR<Format>(object.addressRange, settings, "VkStridedDeviceAddressRangeKHR", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.addressFlags, settings, "VkAddressCommandFlagsKHR", "addressFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDrawIndirect2InfoKHR(const VkDrawIndirect2InfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStridedDeviceAddressRangeKHR<Format>(object.addressRange, settings, "VkStridedDeviceAddressRangeKHR", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.addressFlags, settings, "VkAddressCommandFlagsKHR", "addressFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.drawCount, settings, "uint32_t", "drawCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDrawIndirectCount2InfoKHR(const VkDrawIndirectCount2InfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStridedDeviceAddressRangeKHR<Format>(object.addressRange, settings, "VkStridedDeviceAddressRangeKHR", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.addressFlags, settings, "VkAddressCommandFlagsKHR", "addressFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.countAddressRange, settings, "VkDeviceAddressRangeKHR", "countAddressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.countAddressFlags, settings, "VkAddressCommandFlagsKHR", "countAddressFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDrawCount, settings, "uint32_t", "maxDrawCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDispatchIndirect2InfoKHR(const VkDispatchIndirect2InfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.addressRange, settings, "VkDeviceAddressRangeKHR", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.addressFlags, settings, "VkAddressCommandFlagsKHR", "addressFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkConditionalRenderingBeginInfo2EXT(const VkConditionalRenderingBeginInfo2EXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.addressRange, settings, "VkDeviceAddressRangeKHR", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.addressFlags, settings, "VkAddressCommandFlagsKHR", "addressFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkConditionalRenderingFlagsEXT<Format>(object.flags, settings, "VkConditionalRenderingFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindTransformFeedbackBuffer2InfoEXT(const VkBindTransformFeedbackBuffer2InfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.addressRange, settings, "VkDeviceAddressRangeKHR", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.addressFlags, settings, "VkAddressCommandFlagsKHR", "addressFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryMarkerInfoAMD(const VkMemoryMarkerInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.stage, settings, "VkPipelineStageFlags2KHR", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.dstRange, settings, "VkDeviceAddressRangeKHR", "dstRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.dstFlags, settings, "VkAddressCommandFlagsKHR", "dstFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.marker, settings, "uint32_t", "marker", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureCreateInfo2KHR(const VkAccelerationStructureCreateInfo2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureCreateFlagsKHR<Format>(object.createFlags, settings, "VkAccelerationStructureCreateFlagsKHR", "createFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.addressRange, settings, "VkDeviceAddressRangeKHR", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCommandFlagsKHR<Format>(object.addressFlags, settings, "VkAddressCommandFlagsKHR", "addressFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureTypeKHR<Format>(object.type, settings, "VkAccelerationStructureTypeKHR", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShaderBarycentric, settings, "VkBool32", "fragmentShaderBarycentric", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.triStripVertexOrderIndependentOfProvokingVertex, settings, "VkBool32", "triStripVertexOrderIndependentOfProvokingVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSubgroupUniformControlFlow, settings, "VkBool32", "shaderSubgroupUniformControlFlow", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.workgroupMemoryExplicitLayout, settings, "VkBool32", "workgroupMemoryExplicitLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.workgroupMemoryExplicitLayoutScalarBlockLayout, settings, "VkBool32", "workgroupMemoryExplicitLayoutScalarBlockLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.workgroupMemoryExplicitLayout8BitAccess, settings, "VkBool32", "workgroupMemoryExplicitLayout8BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.workgroupMemoryExplicitLayout16BitAccess, settings, "VkBool32", "workgroupMemoryExplicitLayout16BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingMaintenance1, settings, "VkBool32", "rayTracingMaintenance1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingPipelineTraceRaysIndirect2, settings, "VkBool32", "rayTracingPipelineTraceRaysIndirect2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTraceRaysIndirectCommand2KHR(const VkTraceRaysIndirectCommand2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.raygenShaderRecordAddress, settings, "VkDeviceAddress", "raygenShaderRecordAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.raygenShaderRecordSize, settings, "VkDeviceSize", "raygenShaderRecordSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.missShaderBindingTableAddress, settings, "VkDeviceAddress", "missShaderBindingTableAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.missShaderBindingTableSize, settings, "VkDeviceSize", "missShaderBindingTableSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.missShaderBindingTableStride, settings, "VkDeviceSize", "missShaderBindingTableStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.hitShaderBindingTableAddress, settings, "VkDeviceAddress", "hitShaderBindingTableAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.hitShaderBindingTableSize, settings, "VkDeviceSize", "hitShaderBindingTableSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.hitShaderBindingTableStride, settings, "VkDeviceSize", "hitShaderBindingTableStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.callableShaderBindingTableAddress, settings, "VkDeviceAddress", "callableShaderBindingTableAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.callableShaderBindingTableSize, settings, "VkDeviceSize", "callableShaderBindingTableSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.callableShaderBindingTableStride, settings, "VkDeviceSize", "callableShaderBindingTableStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.depth, settings, "uint32_t", "depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR(const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderUntypedPointers, settings, "VkBool32", "shaderUntypedPointers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderMaximalReconvergence, settings, "VkBool32", "shaderMaximalReconvergence", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceCapabilitiesPresentId2KHR(const VkSurfaceCapabilitiesPresentId2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentId2Supported, settings, "VkBool32", "presentId2Supported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentId2KHR(const VkPresentId2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPresentIds, object.swapchainCount, settings, "const uint64_t*", "pPresentIds", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePresentId2FeaturesKHR(const VkPhysicalDevicePresentId2FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentId2, settings, "VkBool32", "presentId2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceCapabilitiesPresentWait2KHR(const VkSurfaceCapabilitiesPresentWait2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentWait2Supported, settings, "VkBool32", "presentWait2Supported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePresentWait2FeaturesKHR(const VkPhysicalDevicePresentWait2FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentWait2, settings, "VkBool32", "presentWait2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentWait2InfoKHR(const VkPresentWait2InfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.presentId, settings, "uint64_t", "presentId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.timeout, settings, "uint64_t", "timeout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingPositionFetch, settings, "VkBool32", "rayTracingPositionFetch", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePipelineBinaryFeaturesKHR(const VkPhysicalDevicePipelineBinaryFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineBinaries, settings, "VkBool32", "pipelineBinaries", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePipelineBinaryPropertiesKHR(const VkPhysicalDevicePipelineBinaryPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineBinaryInternalCache, settings, "VkBool32", "pipelineBinaryInternalCache", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineBinaryInternalCacheControl, settings, "VkBool32", "pipelineBinaryInternalCacheControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineBinaryPrefersInternalCache, settings, "VkBool32", "pipelineBinaryPrefersInternalCache", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineBinaryPrecompiledInternalCache, settings, "VkBool32", "pipelineBinaryPrecompiledInternalCache", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineBinaryCompressedData, settings, "VkBool32", "pipelineBinaryCompressedData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDevicePipelineBinaryInternalCacheControlKHR(const VkDevicePipelineBinaryInternalCacheControlKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.disableInternalCache, settings, "VkBool32", "disableInternalCache", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineBinaryKeyKHR(const VkPipelineBinaryKeyKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.keySize, settings, "uint32_t", "keySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.key, VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR, settings, "uint8_t[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR]", "key", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineBinaryDataKHR(const VkPipelineBinaryDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, size_t>(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pData, settings, "void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineBinaryKeysAndDataKHR(const VkPipelineBinaryKeysAndDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.binaryCount, settings, "uint32_t", "binaryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPipelineBinaryKeys, object.binaryCount, settings, "const VkPipelineBinaryKeyKHR*", "pPipelineBinaryKeys", "const VkPipelineBinaryKeyKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKeyKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPipelineBinaryData, object.binaryCount, settings, "const VkPipelineBinaryDataKHR*", "pPipelineBinaryData", "const VkPipelineBinaryDataKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryDataKHR<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCreateInfoKHR(const VkPipelineCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineBinaryCreateInfoKHR(const VkPipelineBinaryCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pKeysAndDataInfo, settings, "const VkPipelineBinaryKeysAndDataKHR*", "pKeysAndDataInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKeysAndDataKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pPipelineCreateInfo, settings, "const VkPipelineCreateInfoKHR*", "pPipelineCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineCreateInfoKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineBinaryInfoKHR(const VkPipelineBinaryInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.binaryCount, settings, "uint32_t", "binaryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPipelineBinaries, object.binaryCount, settings, "const VkPipelineBinaryKHR*", "pPipelineBinaries", "const VkPipelineBinaryKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkReleaseCapturedPipelineDataInfoKHR(const VkReleaseCapturedPipelineDataInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineBinaryDataInfoKHR(const VkPipelineBinaryDataInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineBinaryKHR<Format>(object.pipelineBinary, settings, "VkPipelineBinaryKHR", "pipelineBinary", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineBinaryHandlesInfoKHR(const VkPipelineBinaryHandlesInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pipelineBinaryCount, settings, "uint32_t", "pipelineBinaryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPipelineBinaries, object.pipelineBinaryCount, settings, "VkPipelineBinaryKHR*", "pPipelineBinaries", "VkPipelineBinaryKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfacePresentModeKHR(const VkSurfacePresentModeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentModeKHR<Format>(object.presentMode, settings, "VkPresentModeKHR", "presentMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfacePresentScalingCapabilitiesKHR(const VkSurfacePresentScalingCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentScalingFlagsKHR<Format>(object.supportedPresentScaling, settings, "VkPresentScalingFlagsKHR", "supportedPresentScaling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentGravityFlagsKHR<Format>(object.supportedPresentGravityX, settings, "VkPresentGravityFlagsKHR", "supportedPresentGravityX", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentGravityFlagsKHR<Format>(object.supportedPresentGravityY, settings, "VkPresentGravityFlagsKHR", "supportedPresentGravityY", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.minScaledImageExtent, settings, "VkExtent2D", "minScaledImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxScaledImageExtent, settings, "VkExtent2D", "maxScaledImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfacePresentModeCompatibilityKHR(const VkSurfacePresentModeCompatibilityKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.presentModeCount, settings, "uint32_t", "presentModeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPresentModes, object.presentModeCount, settings, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.swapchainMaintenance1, settings, "VkBool32", "swapchainMaintenance1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainPresentFenceInfoKHR(const VkSwapchainPresentFenceInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pFences, object.swapchainCount, settings, "const VkFence*", "pFences", "const VkFence", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFence<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainPresentModesCreateInfoKHR(const VkSwapchainPresentModesCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.presentModeCount, settings, "uint32_t", "presentModeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPresentModes, object.presentModeCount, settings, "const VkPresentModeKHR*", "pPresentModes", "const VkPresentModeKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainPresentModeInfoKHR(const VkSwapchainPresentModeInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPresentModes, object.swapchainCount, settings, "const VkPresentModeKHR*", "pPresentModes", "const VkPresentModeKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainPresentScalingCreateInfoKHR(const VkSwapchainPresentScalingCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentScalingFlagsKHR<Format>(object.scalingBehavior, settings, "VkPresentScalingFlagsKHR", "scalingBehavior", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentGravityFlagsKHR<Format>(object.presentGravityX, settings, "VkPresentGravityFlagsKHR", "presentGravityX", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentGravityFlagsKHR<Format>(object.presentGravityY, settings, "VkPresentGravityFlagsKHR", "presentGravityY", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkReleaseSwapchainImagesInfoKHR(const VkReleaseSwapchainImagesInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSwapchainKHR<Format>(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.imageIndexCount, settings, "uint32_t", "imageIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pImageIndices, object.imageIndexCount, settings, "const uint32_t*", "pImageIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.internallySynchronizedQueues, settings, "VkBool32", "internallySynchronizedQueues", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.MSize, settings, "uint32_t", "MSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.NSize, settings, "uint32_t", "NSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.KSize, settings, "uint32_t", "KSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.AType, settings, "VkComponentTypeKHR", "AType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.BType, settings, "VkComponentTypeKHR", "BType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.CType, settings, "VkComponentTypeKHR", "CType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.ResultType, settings, "VkComponentTypeKHR", "ResultType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.saturatingAccumulation, settings, "VkBool32", "saturatingAccumulation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkScopeKHR<Format>(object.scope, settings, "VkScopeKHR", "scope", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrix, settings, "VkBool32", "cooperativeMatrix", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrixRobustBufferAccess, settings, "VkBool32", "cooperativeMatrixRobustBufferAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.cooperativeMatrixSupportedStages, settings, "VkShaderStageFlags", "cooperativeMatrixSupportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.computeDerivativeGroupQuads, settings, "VkBool32", "computeDerivativeGroupQuads", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.computeDerivativeGroupLinear, settings, "VkBool32", "computeDerivativeGroupLinear", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.meshAndTaskShaderDerivatives, settings, "VkBool32", "meshAndTaskShaderDerivatives", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1Profile<Format>(object.stdProfile, settings, "StdVideoAV1Profile", "stdProfile", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.filmGrainSupport, settings, "VkBool32", "filmGrainSupport", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeAV1CapabilitiesKHR(const VkVideoDecodeAV1CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1Level<Format>(object.maxLevel, settings, "StdVideoAV1Level", "maxLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeAV1SessionParametersCreateInfoKHR(const VkVideoDecodeAV1SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdSequenceHeader, settings, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1SequenceHeader<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeAV1PictureInfoKHR(const VkVideoDecodeAV1PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdPictureInfo, settings, "const StdVideoDecodeAV1PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeAV1PictureInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR, settings, "int32_t[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]", "referenceNameSlotIndices", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.frameHeaderOffset, settings, "uint32_t", "frameHeaderOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tileCount, settings, "uint32_t", "tileCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTileOffsets, object.tileCount, settings, "const uint32_t*", "pTileOffsets", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTileSizes, object.tileCount, settings, "const uint32_t*", "pTileSizes", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeAV1DpbSlotInfoKHR(const VkVideoDecodeAV1DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdReferenceInfo, settings, "const StdVideoDecodeAV1ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeAV1ReferenceInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.videoEncodeAV1, settings, "VkBool32", "videoEncodeAV1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1CapabilitiesKHR(const VkVideoEncodeAV1CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1CapabilityFlagsKHR<Format>(object.flags, settings, "VkVideoEncodeAV1CapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1Level<Format>(object.maxLevel, settings, "StdVideoAV1Level", "maxLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.codedPictureAlignment, settings, "VkExtent2D", "codedPictureAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxTiles, settings, "VkExtent2D", "maxTiles", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.minTileSize, settings, "VkExtent2D", "minTileSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxTileSize, settings, "VkExtent2D", "maxTileSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1SuperblockSizeFlagsKHR<Format>(object.superblockSizes, settings, "VkVideoEncodeAV1SuperblockSizeFlagsKHR", "superblockSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSingleReferenceCount, settings, "uint32_t", "maxSingleReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.singleReferenceNameMask, settings, "uint32_t", "singleReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxUnidirectionalCompoundReferenceCount, settings, "uint32_t", "maxUnidirectionalCompoundReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxUnidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "maxUnidirectionalCompoundGroup1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.unidirectionalCompoundReferenceNameMask, settings, "uint32_t", "unidirectionalCompoundReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxBidirectionalCompoundReferenceCount, settings, "uint32_t", "maxBidirectionalCompoundReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxBidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "maxBidirectionalCompoundGroup1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxBidirectionalCompoundGroup2ReferenceCount, settings, "uint32_t", "maxBidirectionalCompoundGroup2ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bidirectionalCompoundReferenceNameMask, settings, "uint32_t", "bidirectionalCompoundReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTemporalLayerCount, settings, "uint32_t", "maxTemporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSpatialLayerCount, settings, "uint32_t", "maxSpatialLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxOperatingPoints, settings, "uint32_t", "maxOperatingPoints", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minQIndex, settings, "uint32_t", "minQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxQIndex, settings, "uint32_t", "maxQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.prefersGopRemainingFrames, settings, "VkBool32", "prefersGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.requiresGopRemainingFrames, settings, "VkBool32", "requiresGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1StdFlagsKHR<Format>(object.stdSyntaxFlags, settings, "VkVideoEncodeAV1StdFlagsKHR", "stdSyntaxFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1QIndexKHR(const VkVideoEncodeAV1QIndexKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.intraQIndex, settings, "uint32_t", "intraQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.predictiveQIndex, settings, "uint32_t", "predictiveQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bipredictiveQIndex, settings, "uint32_t", "bipredictiveQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1QualityLevelPropertiesKHR(const VkVideoEncodeAV1QualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1RateControlFlagsKHR<Format>(object.preferredRateControlFlags, settings, "VkVideoEncodeAV1RateControlFlagsKHR", "preferredRateControlFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredGopFrameCount, settings, "uint32_t", "preferredGopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredKeyFramePeriod, settings, "uint32_t", "preferredKeyFramePeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredConsecutiveBipredictiveFrameCount, settings, "uint32_t", "preferredConsecutiveBipredictiveFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredTemporalLayerCount, settings, "uint32_t", "preferredTemporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1QIndexKHR<Format>(object.preferredConstantQIndex, settings, "VkVideoEncodeAV1QIndexKHR", "preferredConstantQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredMaxSingleReferenceCount, settings, "uint32_t", "preferredMaxSingleReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredSingleReferenceNameMask, settings, "uint32_t", "preferredSingleReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredMaxUnidirectionalCompoundReferenceCount, settings, "uint32_t", "preferredMaxUnidirectionalCompoundReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredMaxUnidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "preferredMaxUnidirectionalCompoundGroup1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredUnidirectionalCompoundReferenceNameMask, settings, "uint32_t", "preferredUnidirectionalCompoundReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredMaxBidirectionalCompoundReferenceCount, settings, "uint32_t", "preferredMaxBidirectionalCompoundReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredMaxBidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "preferredMaxBidirectionalCompoundGroup1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredMaxBidirectionalCompoundGroup2ReferenceCount, settings, "uint32_t", "preferredMaxBidirectionalCompoundGroup2ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.preferredBidirectionalCompoundReferenceNameMask, settings, "uint32_t", "preferredBidirectionalCompoundReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1SessionCreateInfoKHR(const VkVideoEncodeAV1SessionCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMaxLevel, settings, "VkBool32", "useMaxLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1Level<Format>(object.maxLevel, settings, "StdVideoAV1Level", "maxLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1SessionParametersCreateInfoKHR(const VkVideoEncodeAV1SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdSequenceHeader, settings, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1SequenceHeader<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdDecoderModelInfo, settings, "const StdVideoEncodeAV1DecoderModelInfo*", "pStdDecoderModelInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1DecoderModelInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stdOperatingPointCount, settings, "uint32_t", "stdOperatingPointCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStdOperatingPoints, object.stdOperatingPointCount, settings, "const StdVideoEncodeAV1OperatingPointInfo*", "pStdOperatingPoints", "const StdVideoEncodeAV1OperatingPointInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1OperatingPointInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1PictureInfoKHR(const VkVideoEncodeAV1PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1PredictionModeKHR<Format>(object.predictionMode, settings, "VkVideoEncodeAV1PredictionModeKHR", "predictionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1RateControlGroupKHR<Format>(object.rateControlGroup, settings, "VkVideoEncodeAV1RateControlGroupKHR", "rateControlGroup", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.constantQIndex, settings, "uint32_t", "constantQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdPictureInfo, settings, "const StdVideoEncodeAV1PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1PictureInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR, settings, "int32_t[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]", "referenceNameSlotIndices", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primaryReferenceCdfOnly, settings, "VkBool32", "primaryReferenceCdfOnly", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.generateObuExtensionHeader, settings, "VkBool32", "generateObuExtensionHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1DpbSlotInfoKHR(const VkVideoEncodeAV1DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdReferenceInfo, settings, "const StdVideoEncodeAV1ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1ReferenceInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1ProfileInfoKHR(const VkVideoEncodeAV1ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoAV1Profile<Format>(object.stdProfile, settings, "StdVideoAV1Profile", "stdProfile", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1FrameSizeKHR(const VkVideoEncodeAV1FrameSizeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.intraFrameSize, settings, "uint32_t", "intraFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.predictiveFrameSize, settings, "uint32_t", "predictiveFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bipredictiveFrameSize, settings, "uint32_t", "bipredictiveFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1GopRemainingFrameInfoKHR(const VkVideoEncodeAV1GopRemainingFrameInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useGopRemainingFrames, settings, "VkBool32", "useGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopRemainingIntra, settings, "uint32_t", "gopRemainingIntra", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopRemainingPredictive, settings, "uint32_t", "gopRemainingPredictive", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopRemainingBipredictive, settings, "uint32_t", "gopRemainingBipredictive", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1RateControlInfoKHR(const VkVideoEncodeAV1RateControlInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1RateControlFlagsKHR<Format>(object.flags, settings, "VkVideoEncodeAV1RateControlFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gopFrameCount, settings, "uint32_t", "gopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.keyFramePeriod, settings, "uint32_t", "keyFramePeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.consecutiveBipredictiveFrameCount, settings, "uint32_t", "consecutiveBipredictiveFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.temporalLayerCount, settings, "uint32_t", "temporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1RateControlLayerInfoKHR(const VkVideoEncodeAV1RateControlLayerInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMinQIndex, settings, "VkBool32", "useMinQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1QIndexKHR<Format>(object.minQIndex, settings, "VkVideoEncodeAV1QIndexKHR", "minQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMaxQIndex, settings, "VkBool32", "useMaxQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1QIndexKHR<Format>(object.maxQIndex, settings, "VkVideoEncodeAV1QIndexKHR", "maxQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useMaxFrameSize, settings, "VkBool32", "useMaxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1FrameSizeKHR<Format>(object.maxFrameSize, settings, "VkVideoEncodeAV1FrameSizeKHR", "maxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.videoDecodeVP9, settings, "VkBool32", "videoDecodeVP9", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeVP9ProfileInfoKHR(const VkVideoDecodeVP9ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoVP9Profile<Format>(object.stdProfile, settings, "StdVideoVP9Profile", "stdProfile", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeVP9CapabilitiesKHR(const VkVideoDecodeVP9CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_StdVideoVP9Level<Format>(object.maxLevel, settings, "StdVideoVP9Level", "maxLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeVP9PictureInfoKHR(const VkVideoDecodeVP9PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdPictureInfo, settings, "const StdVideoDecodeVP9PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeVP9PictureInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.referenceNameSlotIndices, VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR, settings, "int32_t[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR]", "referenceNameSlotIndices", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, int32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.uncompressedHeaderOffset, settings, "uint32_t", "uncompressedHeaderOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.compressedHeaderOffset, settings, "uint32_t", "compressedHeaderOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tilesOffset, settings, "uint32_t", "tilesOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.videoMaintenance1, settings, "VkBool32", "videoMaintenance1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueryPool<Format>(object.queryPool, settings, "VkQueryPool", "queryPool", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.firstQuery, settings, "uint32_t", "firstQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queryCount, settings, "uint32_t", "queryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.unifiedImageLayouts, settings, "VkBool32", "unifiedImageLayouts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.unifiedImageLayoutsVideo, settings, "VkBool32", "unifiedImageLayoutsVideo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentFeedbackLoopInfoEXT(const VkAttachmentFeedbackLoopInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.feedbackLoopEnable, settings, "VkBool32", "feedbackLoopEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTimeDomainKHR<Format>(object.timeDomain, settings, "VkTimeDomainKHR", "timeDomain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSetDescriptorBufferOffsetsInfoEXT(const VkSetDescriptorBufferOffsetsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.firstSet, settings, "uint32_t", "firstSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.setCount, settings, "uint32_t", "setCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pBufferIndices, object.setCount, settings, "const uint32_t*", "pBufferIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pOffsets, object.setCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const VkDeviceSize>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.set, settings, "uint32_t", "set", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyMemoryIndirectCommandKHR(const VkCopyMemoryIndirectCommandKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.srcAddress, settings, "VkDeviceAddress", "srcAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.dstAddress, settings, "VkDeviceAddress", "dstAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyMemoryIndirectInfoKHR(const VkCopyMemoryIndirectInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCopyFlagsKHR<Format>(object.srcCopyFlags, settings, "VkAddressCopyFlagsKHR", "srcCopyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCopyFlagsKHR<Format>(object.dstCopyFlags, settings, "VkAddressCopyFlagsKHR", "dstCopyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.copyCount, settings, "uint32_t", "copyCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStridedDeviceAddressRangeKHR<Format>(object.copyAddressRange, settings, "VkStridedDeviceAddressRangeKHR", "copyAddressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyMemoryToImageIndirectCommandKHR(const VkCopyMemoryToImageIndirectCommandKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.srcAddress, settings, "VkDeviceAddress", "srcAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bufferRowLength, settings, "uint32_t", "bufferRowLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bufferImageHeight, settings, "uint32_t", "bufferImageHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageSubresourceLayers<Format>(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset3D<Format>(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyMemoryToImageIndirectInfoKHR(const VkCopyMemoryToImageIndirectInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAddressCopyFlagsKHR<Format>(object.srcCopyFlags, settings, "VkAddressCopyFlagsKHR", "srcCopyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.copyCount, settings, "uint32_t", "copyCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStridedDeviceAddressRangeKHR<Format>(object.copyAddressRange, settings, "VkStridedDeviceAddressRangeKHR", "copyAddressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pImageSubresources, object.copyCount, settings, "const VkImageSubresourceLayers*", "pImageSubresources", "const VkImageSubresourceLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageSubresourceLayers<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.indirectMemoryCopy, settings, "VkBool32", "indirectMemoryCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.indirectMemoryToImageCopy, settings, "VkBool32", "indirectMemoryToImageCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueueFlags<Format>(object.supportedQueues, settings, "VkQueueFlags", "supportedQueues", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeIntraRefreshCapabilitiesKHR(const VkVideoEncodeIntraRefreshCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeIntraRefreshModeFlagsKHR<Format>(object.intraRefreshModes, settings, "VkVideoEncodeIntraRefreshModeFlagsKHR", "intraRefreshModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIntraRefreshCycleDuration, settings, "uint32_t", "maxIntraRefreshCycleDuration", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIntraRefreshActiveReferencePictures, settings, "uint32_t", "maxIntraRefreshActiveReferencePictures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.partitionIndependentIntraRefreshRegions, settings, "VkBool32", "partitionIndependentIntraRefreshRegions", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nonRectangularIntraRefreshRegions, settings, "VkBool32", "nonRectangularIntraRefreshRegions", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeSessionIntraRefreshCreateInfoKHR(const VkVideoEncodeSessionIntraRefreshCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeIntraRefreshModeFlagBitsKHR<Format>(object.intraRefreshMode, settings, "VkVideoEncodeIntraRefreshModeFlagBitsKHR", "intraRefreshMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeIntraRefreshInfoKHR(const VkVideoEncodeIntraRefreshInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.intraRefreshCycleDuration, settings, "uint32_t", "intraRefreshCycleDuration", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.intraRefreshIndex, settings, "uint32_t", "intraRefreshIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoReferenceIntraRefreshInfoKHR(const VkVideoReferenceIntraRefreshInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dirtyIntraRefreshRegions, settings, "uint32_t", "dirtyIntraRefreshRegions", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.videoEncodeIntraRefresh, settings, "VkBool32", "videoEncodeIntraRefresh", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeQuantizationMapCapabilitiesKHR(const VkVideoEncodeQuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxQuantizationMapExtent, settings, "VkExtent2D", "maxQuantizationMapExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoFormatQuantizationMapPropertiesKHR(const VkVideoFormatQuantizationMapPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.quantizationMapTexelSize, settings, "VkExtent2D", "quantizationMapTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeQuantizationMapInfoKHR(const VkVideoEncodeQuantizationMapInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageView<Format>(object.quantizationMap, settings, "VkImageView", "quantizationMap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.quantizationMapExtent, settings, "VkExtent2D", "quantizationMapExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.quantizationMapTexelSize, settings, "VkExtent2D", "quantizationMapTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.videoEncodeQuantizationMap, settings, "VkBool32", "videoEncodeQuantizationMap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(const VkVideoEncodeH264QuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.minQpDelta, settings, "int32_t", "minQpDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.maxQpDelta, settings, "int32_t", "maxQpDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(const VkVideoEncodeH265QuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.minQpDelta, settings, "int32_t", "minQpDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.maxQpDelta, settings, "int32_t", "maxQpDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoFormatH265QuantizationMapPropertiesKHR(const VkVideoFormatH265QuantizationMapPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeH265CtbSizeFlagsKHR<Format>(object.compatibleCtbSizes, settings, "VkVideoEncodeH265CtbSizeFlagsKHR", "compatibleCtbSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.minQIndexDelta, settings, "int32_t", "minQIndexDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.maxQIndexDelta, settings, "int32_t", "maxQIndexDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoFormatAV1QuantizationMapPropertiesKHR(const VkVideoFormatAV1QuantizationMapPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeAV1SuperblockSizeFlagsKHR<Format>(object.compatibleSuperblockSizes, settings, "VkVideoEncodeAV1SuperblockSizeFlagsKHR", "compatibleSuperblockSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRelaxedExtendedInstruction, settings, "VkBool32", "shaderRelaxedExtendedInstruction", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance7FeaturesKHR(const VkPhysicalDeviceMaintenance7FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.maintenance7, settings, "VkBool32", "maintenance7", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance7PropertiesKHR(const VkPhysicalDeviceMaintenance7PropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.robustFragmentShadingRateAttachmentAccess, settings, "VkBool32", "robustFragmentShadingRateAttachmentAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.separateDepthStencilAttachmentAccess, settings, "VkBool32", "separateDepthStencilAttachmentAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetTotalUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetTotalUniformBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetTotalStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetTotalStorageBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetTotalBuffersDynamic, settings, "uint32_t", "maxDescriptorSetTotalBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLayeredApiPropertiesKHR(const VkPhysicalDeviceLayeredApiPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vendorID, settings, "uint32_t", "vendorID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceID, settings, "uint32_t", "deviceID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceLayeredApiKHR<Format>(object.layeredAPI, settings, "VkPhysicalDeviceLayeredApiKHR", "layeredAPI", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.deviceName, settings, "char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]", "deviceName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLayeredApiPropertiesListKHR(const VkPhysicalDeviceLayeredApiPropertiesListKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.layeredApiCount, settings, "uint32_t", "layeredApiCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pLayeredApis, object.layeredApiCount, settings, "VkPhysicalDeviceLayeredApiPropertiesKHR*", "pLayeredApis", "VkPhysicalDeviceLayeredApiPropertiesKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceLayeredApiPropertiesKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceProperties2<Format>(object.properties, settings, "VkPhysicalDeviceProperties2", "properties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFaultFeaturesKHR(const VkPhysicalDeviceFaultFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceFault, settings, "VkBool32", "deviceFault", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceFaultVendorBinary, settings, "VkBool32", "deviceFaultVendorBinary", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceFaultReportMasked, settings, "VkBool32", "deviceFaultReportMasked", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceFaultDeviceLostOnMasked, settings, "VkBool32", "deviceFaultDeviceLostOnMasked", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFaultPropertiesKHR(const VkPhysicalDeviceFaultPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDeviceFaultCount, settings, "uint32_t", "maxDeviceFaultCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceFaultAddressInfoKHR(const VkDeviceFaultAddressInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkDeviceFaultAddressTypeKHR<Format>(object.addressType, settings, "VkDeviceFaultAddressTypeKHR", "addressType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.reportedAddress, settings, "VkDeviceAddress", "reportedAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.addressPrecision, settings, "VkDeviceSize", "addressPrecision", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceFaultVendorInfoKHR(const VkDeviceFaultVendorInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_char<Format>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.vendorFaultCode, settings, "uint64_t", "vendorFaultCode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.vendorFaultData, settings, "uint64_t", "vendorFaultData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceFaultInfoKHR(const VkDeviceFaultInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceFaultFlagsKHR<Format>(object.flags, settings, "VkDeviceFaultFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.groupId, settings, "uint64_t", "groupId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceFaultAddressInfoKHR<Format>(object.faultAddressInfo, settings, "VkDeviceFaultAddressInfoKHR", "faultAddressInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceFaultAddressInfoKHR<Format>(object.instructionAddressInfo, settings, "VkDeviceFaultAddressInfoKHR", "instructionAddressInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceFaultVendorInfoKHR<Format>(object.vendorInfo, settings, "VkDeviceFaultVendorInfoKHR", "vendorInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceFaultDebugInfoKHR(const VkDeviceFaultDebugInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vendorBinarySize, settings, "uint32_t", "vendorBinarySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pVendorBinaryData, settings, "void*", "pVendorBinaryData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceFaultVendorBinaryHeaderVersionOneKHR(const VkDeviceFaultVendorBinaryHeaderVersionOneKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.headerSize, settings, "uint32_t", "headerSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceFaultVendorBinaryHeaderVersionKHR<Format>(object.headerVersion, settings, "VkDeviceFaultVendorBinaryHeaderVersionKHR", "headerVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vendorID, settings, "uint32_t", "vendorID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceID, settings, "uint32_t", "deviceID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.driverVersion, settings, "uint32_t", "driverVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.pipelineCacheUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "pipelineCacheUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.applicationNameOffset, settings, "uint32_t", "applicationNameOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.applicationVersion, settings, "uint32_t", "applicationVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.engineNameOffset, settings, "uint32_t", "engineNameOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.engineVersion, settings, "uint32_t", "engineVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_api_version<Format>(object.apiVersion, settings, "uint32_t", "apiVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryBarrierAccessFlags3KHR(const VkMemoryBarrierAccessFlags3KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags3KHR<Format>(object.srcAccessMask3, settings, "VkAccessFlags3KHR", "srcAccessMask3", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags3KHR<Format>(object.dstAccessMask3, settings, "VkAccessFlags3KHR", "dstAccessMask3", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance8FeaturesKHR(const VkPhysicalDeviceMaintenance8FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.maintenance8, settings, "VkBool32", "maintenance8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderFmaFeaturesKHR(const VkPhysicalDeviceShaderFmaFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFmaFloat16, settings, "VkBool32", "shaderFmaFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFmaFloat32, settings, "VkBool32", "shaderFmaFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFmaFloat64, settings, "VkBool32", "shaderFmaFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance9FeaturesKHR(const VkPhysicalDeviceMaintenance9FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.maintenance9, settings, "VkBool32", "maintenance9", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance9PropertiesKHR(const VkPhysicalDeviceMaintenance9PropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.image2DViewOf3DSparse, settings, "VkBool32", "image2DViewOf3DSparse", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDefaultVertexAttributeValueKHR<Format>(object.defaultVertexAttributeValue, settings, "VkDefaultVertexAttributeValueKHR", "defaultVertexAttributeValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyOwnershipTransferPropertiesKHR(const VkQueueFamilyOwnershipTransferPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.optimalImageTransferToQueueFamilies, settings, "uint32_t", "optimalImageTransferToQueueFamilies", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(const VkPhysicalDeviceVideoMaintenance2FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.videoMaintenance2, settings, "VkBool32", "videoMaintenance2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH264InlineSessionParametersInfoKHR(const VkVideoDecodeH264InlineSessionParametersInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdSPS, settings, "const StdVideoH264SequenceParameterSet*", "pStdSPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSet<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdPPS, settings, "const StdVideoH264PictureParameterSet*", "pStdPPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264PictureParameterSet<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeH265InlineSessionParametersInfoKHR(const VkVideoDecodeH265InlineSessionParametersInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdVPS, settings, "const StdVideoH265VideoParameterSet*", "pStdVPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265VideoParameterSet<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdSPS, settings, "const StdVideoH265SequenceParameterSet*", "pStdSPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSet<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdPPS, settings, "const StdVideoH265PictureParameterSet*", "pStdPPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PictureParameterSet<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoDecodeAV1InlineSessionParametersInfoKHR(const VkVideoDecodeAV1InlineSessionParametersInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pStdSequenceHeader, settings, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1SequenceHeader<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR(const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.videoEncodeFeedback2, settings, "VkBool32", "videoEncodeFeedback2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeFeedback2CapabilitiesKHR(const VkVideoEncodeFeedback2CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerPartitionFeedbackEntries, settings, "uint32_t", "maxPerPartitionFeedbackEntries", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodePerPartitionFeedbackFlagsKHR<Format>(object.supportedPerPartitionEncodeFeedbackFlags, settings, "VkVideoEncodePerPartitionFeedbackFlagsKHR", "supportedPerPartitionEncodeFeedbackFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR(const VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerPartitionFeedbackEntries, settings, "uint32_t", "maxPerPartitionFeedbackEntries", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodePerPartitionFeedbackFlagsKHR<Format>(object.perPartitionEncodeFeedbackFlags, settings, "VkVideoEncodePerPartitionFeedbackFlagsKHR", "perPartitionEncodeFeedbackFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthClampZeroOne, settings, "VkBool32", "depthClampZeroOne", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRobustness2FeaturesKHR(const VkPhysicalDeviceRobustness2FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.robustBufferAccess2, settings, "VkBool32", "robustBufferAccess2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.robustImageAccess2, settings, "VkBool32", "robustImageAccess2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nullDescriptor, settings, "VkBool32", "nullDescriptor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRobustness2PropertiesKHR(const VkPhysicalDeviceRobustness2PropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.robustStorageBufferAccessSizeAlignment, settings, "VkDeviceSize", "robustStorageBufferAccessSizeAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.robustUniformBufferAccessSizeAlignment, settings, "VkDeviceSize", "robustUniformBufferAccessSizeAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentModeFifoLatestReady, settings, "VkBool32", "presentModeFifoLatestReady", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMicromapUsageKHR(const VkMicromapUsageKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.count, settings, "uint32_t", "count", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subdivisionLevel, settings, "uint32_t", "subdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOpacityMicromapFormatKHR<Format>(object.format, settings, "VkOpacityMicromapFormatKHR", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureGeometryMicromapDataKHR(const VkAccelerationStructureGeometryMicromapDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.usageCountsCount, settings, "uint32_t", "usageCountsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pUsageCounts, object.usageCountsCount, settings, "const VkMicromapUsageKHR*", "pUsageCounts", "const VkMicromapUsageKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_double_pointer_array<Format>(object.ppUsageCounts, object.usageCountsCount * 1, settings, "const VkMicromapUsageKHR* const*", "ppUsageCounts", "const VkMicromapUsageKHR*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.data, settings, "VkDeviceAddress", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.triangleArray, settings, "VkDeviceAddress", "triangleArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.triangleArrayStride, settings, "VkDeviceSize", "triangleArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceOpacityMicromapFeaturesKHR(const VkPhysicalDeviceOpacityMicromapFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.micromap, settings, "VkBool32", "micromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceOpacityMicromapPropertiesKHR(const VkPhysicalDeviceOpacityMicromapPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxOpacity2StateSubdivisionLevel, settings, "uint32_t", "maxOpacity2StateSubdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxOpacity4StateSubdivisionLevel, settings, "uint32_t", "maxOpacity4StateSubdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxOpacityLossy4StateSubdivisionLevel, settings, "uint32_t", "maxOpacityLossy4StateSubdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxMicromapTriangles, settings, "uint64_t", "maxMicromapTriangles", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMicromapTriangleKHR(const VkMicromapTriangleKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.dataOffset, settings, "uint32_t", "dataOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.subdivisionLevel, settings, "uint16_t", "subdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.format, settings, "uint16_t", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureTrianglesOpacityMicromapKHR(const VkAccelerationStructureTrianglesOpacityMicromapKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndexType<Format>(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.indexBuffer, settings, "VkDeviceAddress", "indexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.baseTriangle, settings, "uint32_t", "baseTriangle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureKHR<Format>(object.micromap, settings, "VkAccelerationStructureKHR", "micromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance10FeaturesKHR(const VkPhysicalDeviceMaintenance10FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.maintenance10, settings, "VkBool32", "maintenance10", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance10PropertiesKHR(const VkPhysicalDeviceMaintenance10PropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rgba4OpaqueBlackSwizzled, settings, "VkBool32", "rgba4OpaqueBlackSwizzled", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.resolveSrgbFormatAppliesTransferFunction, settings, "VkBool32", "resolveSrgbFormatAppliesTransferFunction", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.resolveSrgbFormatSupportsTransferFunctionControl, settings, "VkBool32", "resolveSrgbFormatSupportsTransferFunctionControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderingEndInfoKHR(const VkRenderingEndInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderingAttachmentFlagsInfoKHR(const VkRenderingAttachmentFlagsInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRenderingAttachmentFlagsKHR<Format>(object.flags, settings, "VkRenderingAttachmentFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkResolveImageModeInfoKHR(const VkResolveImageModeInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkResolveImageFlagsKHR<Format>(object.flags, settings, "VkResolveImageFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkResolveModeFlagBits<Format>(object.resolveMode, settings, "VkResolveModeFlagBits", "resolveMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkResolveModeFlagBits<Format>(object.stencilResolveMode, settings, "VkResolveModeFlagBits", "stencilResolveMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMaintenance11FeaturesKHR(const VkPhysicalDeviceMaintenance11FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.maintenance11, settings, "VkBool32", "maintenance11", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR(const VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.optimalImageTransferGranularity, settings, "VkExtent3D", "optimalImageTransferGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFormatProperties4KHR(const VkFormatProperties4KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags4KHR<Format>(object.linearTilingFeatures, settings, "VkFormatFeatureFlags4KHR", "linearTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags4KHR<Format>(object.optimalTilingFeatures, settings, "VkFormatFeatureFlags4KHR", "optimalTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags4KHR<Format>(object.bufferFeatures, settings, "VkFormatFeatureFlags4KHR", "bufferFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageUsageFlags2CreateInfoKHR(const VkImageUsageFlags2CreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags2KHR<Format>(object.usage, settings, "VkImageUsageFlags2KHR", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageCreateFlags2CreateInfoKHR(const VkImageCreateFlags2CreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageCreateFlags2KHR<Format>(object.flags, settings, "VkImageCreateFlags2KHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageViewUsage2CreateInfoKHR(const VkImageViewUsage2CreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags2KHR<Format>(object.usage, settings, "VkImageUsageFlags2KHR", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExtendedFlagsFeaturesKHR(const VkPhysicalDeviceExtendedFlagsFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedFlags, settings, "VkBool32", "extendedFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageStencilUsage2CreateInfoKHR(const VkImageStencilUsage2CreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags2KHR<Format>(object.stencilUsage, settings, "VkImageUsageFlags2KHR", "stencilUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSharedPresentSurfaceCapabilities2KHR(const VkSharedPresentSurfaceCapabilities2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags2KHR<Format>(object.sharedPresentSupportedUsageFlags, settings, "VkImageUsageFlags2KHR", "sharedPresentSupportedUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDebugReportFlagsEXT<Format>(object.flags, settings, "VkDebugReportFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_PFN_vkDebugReportCallbackEXT<Format>(object.pfnCallback, settings, "PFN_vkDebugReportCallbackEXT", "pfnCallback", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pUserData, settings, "void*", "pUserData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRasterizationOrderAMD<Format>(object.rasterizationOrder, settings, "VkRasterizationOrderAMD", "rasterizationOrder", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDebugReportObjectTypeEXT<Format>(object.objectType, settings, "VkDebugReportObjectTypeEXT", "objectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.object, settings, "uint64_t", "object", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pObjectName, settings, "const char*", "pObjectName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDebugReportObjectTypeEXT<Format>(object.objectType, settings, "VkDebugReportObjectTypeEXT", "objectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.object, settings, "uint64_t", "object", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.tagName, settings, "uint64_t", "tagName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.tagSize, settings, "size_t", "tagSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pTag, settings, "const void*", "pTag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pMarkerName, settings, "const char*", "pMarkerName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.color, 4, settings, "float[4]", "color", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, float>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dedicatedAllocation, settings, "VkBool32", "dedicatedAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dedicatedAllocation, settings, "VkBool32", "dedicatedAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.transformFeedback, settings, "VkBool32", "transformFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.geometryStreams, settings, "VkBool32", "geometryStreams", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTransformFeedbackStreams, settings, "uint32_t", "maxTransformFeedbackStreams", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTransformFeedbackBuffers, settings, "uint32_t", "maxTransformFeedbackBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxTransformFeedbackBufferSize, settings, "VkDeviceSize", "maxTransformFeedbackBufferSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTransformFeedbackStreamDataSize, settings, "uint32_t", "maxTransformFeedbackStreamDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTransformFeedbackBufferDataSize, settings, "uint32_t", "maxTransformFeedbackBufferDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTransformFeedbackBufferDataStride, settings, "uint32_t", "maxTransformFeedbackBufferDataStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.transformFeedbackQueries, settings, "VkBool32", "transformFeedbackQueries", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.transformFeedbackStreamsLinesTriangles, settings, "VkBool32", "transformFeedbackStreamsLinesTriangles", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.transformFeedbackRasterizationStreamSelect, settings, "VkBool32", "transformFeedbackRasterizationStreamSelect", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.transformFeedbackDraw, settings, "VkBool32", "transformFeedbackDraw", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRasterizationStateStreamCreateFlagsEXT<Format>(object.flags, settings, "VkPipelineRasterizationStateStreamCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.rasterizationStream, settings, "uint32_t", "rasterizationStream", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCuModuleCreateInfoNVX(const VkCuModuleCreateInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pData, settings, "const void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCuModuleTexturingModeCreateInfoNVX(const VkCuModuleTexturingModeCreateInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.use64bitTexturing, settings, "VkBool32", "use64bitTexturing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCuModuleNVX<Format>(object.module, settings, "VkCuModuleNVX", "module", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCuLaunchInfoNVX(const VkCuLaunchInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCuFunctionNVX<Format>(object.function, settings, "VkCuFunctionNVX", "function", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gridDimX, settings, "uint32_t", "gridDimX", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gridDimY, settings, "uint32_t", "gridDimY", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gridDimZ, settings, "uint32_t", "gridDimZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.blockDimX, settings, "uint32_t", "blockDimX", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.blockDimY, settings, "uint32_t", "blockDimY", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.blockDimZ, settings, "uint32_t", "blockDimZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sharedMemBytes, settings, "uint32_t", "sharedMemBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.paramCount, settings, "size_t", "paramCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pParams, object.paramCount, settings, "const void* const *", "pParams", "const void*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const void*>);
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.extraCount, settings, "size_t", "extraCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pExtras, object.extraCount, settings, "const void* const *", "pExtras", "const void*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const void*>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageView<Format>(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorType<Format>(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampler<Format>(object.sampler, settings, "VkSampler", "sampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.supportsTextureGatherLODBiasAMD, settings, "VkBool32", "supportsTextureGatherLODBiasAMD", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderResourceUsageAMD(const VkShaderResourceUsageAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.numUsedVgprs, settings, "uint32_t", "numUsedVgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numUsedSgprs, settings, "uint32_t", "numUsedSgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.ldsSizePerLocalWorkGroup, settings, "uint32_t", "ldsSizePerLocalWorkGroup", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.ldsUsageSizeInBytes, settings, "size_t", "ldsUsageSizeInBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.scratchMemUsageInBytes, settings, "size_t", "scratchMemUsageInBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderStatisticsInfoAMD(const VkShaderStatisticsInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkShaderStageFlags<Format>(object.shaderStageMask, settings, "VkShaderStageFlags", "shaderStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderResourceUsageAMD<Format>(object.resourceUsage, settings, "VkShaderResourceUsageAMD", "resourceUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numPhysicalVgprs, settings, "uint32_t", "numPhysicalVgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numPhysicalSgprs, settings, "uint32_t", "numPhysicalSgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numAvailableVgprs, settings, "uint32_t", "numAvailableVgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numAvailableSgprs, settings, "uint32_t", "numAvailableSgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.computeWorkGroupSize, 3, settings, "uint32_t[3]", "computeWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_GGP)
template <ApiDumpFormat Format>
void dump_VkStreamDescriptorSurfaceCreateInfoGGP(const VkStreamDescriptorSurfaceCreateInfoGGP& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStreamDescriptorSurfaceCreateFlagsGGP<Format>(object.flags, settings, "VkStreamDescriptorSurfaceCreateFlagsGGP", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, GgpStreamDescriptor>(object.streamDescriptor, settings, "GgpStreamDescriptor", "streamDescriptor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_GGP
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCornerSampledImageFeaturesNV(const VkPhysicalDeviceCornerSampledImageFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cornerSampledImage, settings, "VkBool32", "cornerSampledImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalImageFormatPropertiesNV(const VkExternalImageFormatPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkImageFormatProperties<Format>(object.imageFormatProperties, settings, "VkImageFormatProperties", "imageFormatProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryFeatureFlagsNV<Format>(object.externalMemoryFeatures, settings, "VkExternalMemoryFeatureFlagsNV", "externalMemoryFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagsNV<Format>(object.exportFromImportedHandleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "exportFromImportedHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagsNV<Format>(object.compatibleHandleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "compatibleHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagsNV<Format>(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagsNV<Format>(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
template <ApiDumpFormat Format>
void dump_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagsNV<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, HANDLE>(object.handle, settings, "HANDLE", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const SECURITY_ATTRIBUTES*>(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, DWORD>(object.dwAccess, settings, "DWORD", "dwAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.acquireCount, settings, "uint32_t", "acquireCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAcquireSyncs, object.acquireCount, settings, "const VkDeviceMemory*", "pAcquireSyncs", "const VkDeviceMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAcquireKeys, object.acquireCount, settings, "const uint64_t*", "pAcquireKeys", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAcquireTimeoutMilliseconds, object.acquireCount, settings, "const uint32_t*", "pAcquireTimeoutMilliseconds", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.releaseCount, settings, "uint32_t", "releaseCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pReleaseSyncs, object.releaseCount, settings, "const VkDeviceMemory*", "pReleaseSyncs", "const VkDeviceMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pReleaseKeys, object.releaseCount, settings, "const uint64_t*", "pReleaseKeys", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR
template <ApiDumpFormat Format>
void dump_VkValidationFlagsEXT(const VkValidationFlagsEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.disabledValidationCheckCount, settings, "uint32_t", "disabledValidationCheckCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDisabledValidationChecks, object.disabledValidationCheckCount, settings, "const VkValidationCheckEXT*", "pDisabledValidationChecks", "const VkValidationCheckEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkValidationCheckEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_VI_NN)
template <ApiDumpFormat Format>
void dump_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkViSurfaceCreateFlagsNN<Format>(object.flags, settings, "VkViSurfaceCreateFlagsNN", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.window, settings, "void*", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_VI_NN
template <ApiDumpFormat Format>
void dump_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.decodeMode, settings, "VkFormat", "decodeMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.decodeModeSharedExponent, settings, "VkBool32", "decodeModeSharedExponent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkConditionalRenderingFlagsEXT<Format>(object.flags, settings, "VkConditionalRenderingFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.conditionalRendering, settings, "VkBool32", "conditionalRendering", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.inheritedConditionalRendering, settings, "VkBool32", "inheritedConditionalRendering", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const VkCommandBufferInheritanceConditionalRenderingInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.conditionalRenderingEnable, settings, "VkBool32", "conditionalRenderingEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkViewportWScalingNV(const VkViewportWScalingNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, float>(object.xcoeff, settings, "float", "xcoeff", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.ycoeff, settings, "float", "ycoeff", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.viewportWScalingEnable, settings, "VkBool32", "viewportWScalingEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewportCount, settings, "uint32_t", "viewportCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pViewportWScalings, object.viewportCount, settings, "const VkViewportWScalingNV*", "pViewportWScalings", "const VkViewportWScalingNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkViewportWScalingNV<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minImageCount, settings, "uint32_t", "minImageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxImageCount, settings, "uint32_t", "maxImageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.currentExtent, settings, "VkExtent2D", "currentExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.minImageExtent, settings, "VkExtent2D", "minImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxImageExtent, settings, "VkExtent2D", "maxImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxImageArrayLayers, settings, "uint32_t", "maxImageArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceTransformFlagsKHR<Format>(object.supportedTransforms, settings, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceTransformFlagBitsKHR<Format>(object.currentTransform, settings, "VkSurfaceTransformFlagBitsKHR", "currentTransform", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCompositeAlphaFlagsKHR<Format>(object.supportedCompositeAlpha, settings, "VkCompositeAlphaFlagsKHR", "supportedCompositeAlpha", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.supportedUsageFlags, settings, "VkImageUsageFlags", "supportedUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceCounterFlagsEXT<Format>(object.supportedSurfaceCounters, settings, "VkSurfaceCounterFlagsEXT", "supportedSurfaceCounters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayPowerStateEXT<Format>(object.powerState, settings, "VkDisplayPowerStateEXT", "powerState", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceEventTypeEXT<Format>(object.deviceEvent, settings, "VkDeviceEventTypeEXT", "deviceEvent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplayEventTypeEXT<Format>(object.displayEvent, settings, "VkDisplayEventTypeEXT", "displayEvent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceCounterFlagsEXT<Format>(object.surfaceCounters, settings, "VkSurfaceCounterFlagsEXT", "surfaceCounters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRefreshCycleDurationGOOGLE(const VkRefreshCycleDurationGOOGLE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint64_t>(object.refreshDuration, settings, "uint64_t", "refreshDuration", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPastPresentationTimingGOOGLE(const VkPastPresentationTimingGOOGLE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.presentID, settings, "uint32_t", "presentID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.desiredPresentTime, settings, "uint64_t", "desiredPresentTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.actualPresentTime, settings, "uint64_t", "actualPresentTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.earliestPresentTime, settings, "uint64_t", "earliestPresentTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.presentMargin, settings, "uint64_t", "presentMargin", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentTimeGOOGLE(const VkPresentTimeGOOGLE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.presentID, settings, "uint32_t", "presentID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.desiredPresentTime, settings, "uint64_t", "desiredPresentTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTimes, object.swapchainCount, settings, "const VkPresentTimeGOOGLE*", "pTimes", "const VkPresentTimeGOOGLE", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentTimeGOOGLE<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.perViewPositionAllComponents, settings, "VkBool32", "perViewPositionAllComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMultiviewPerViewAttributesInfoNVX(const VkMultiviewPerViewAttributesInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.perViewAttributes, settings, "VkBool32", "perViewAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.perViewAttributesPositionXOnly, settings, "VkBool32", "perViewAttributesPositionXOnly", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkViewportSwizzleNV(const VkViewportSwizzleNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkViewportCoordinateSwizzleNV<Format>(object.x, settings, "VkViewportCoordinateSwizzleNV", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkViewportCoordinateSwizzleNV<Format>(object.y, settings, "VkViewportCoordinateSwizzleNV", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkViewportCoordinateSwizzleNV<Format>(object.z, settings, "VkViewportCoordinateSwizzleNV", "z", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkViewportCoordinateSwizzleNV<Format>(object.w, settings, "VkViewportCoordinateSwizzleNV", "w", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineViewportSwizzleStateCreateFlagsNV<Format>(object.flags, settings, "VkPipelineViewportSwizzleStateCreateFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewportCount, settings, "uint32_t", "viewportCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pViewportSwizzles, object.viewportCount, settings, "const VkViewportSwizzleNV*", "pViewportSwizzles", "const VkViewportSwizzleNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkViewportSwizzleNV<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDiscardRectangles, settings, "uint32_t", "maxDiscardRectangles", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineDiscardRectangleStateCreateFlagsEXT<Format>(object.flags, settings, "VkPipelineDiscardRectangleStateCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDiscardRectangleModeEXT<Format>(object.discardRectangleMode, settings, "VkDiscardRectangleModeEXT", "discardRectangleMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.discardRectangleCount, settings, "uint32_t", "discardRectangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDiscardRectangles, object.discardRectangleCount, settings, "const VkRect2D*", "pDiscardRectangles", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.primitiveOverestimationSize, settings, "float", "primitiveOverestimationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxExtraPrimitiveOverestimationSize, settings, "float", "maxExtraPrimitiveOverestimationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.extraPrimitiveOverestimationSizeGranularity, settings, "float", "extraPrimitiveOverestimationSizeGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primitiveUnderestimation, settings, "VkBool32", "primitiveUnderestimation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.conservativePointAndLineRasterization, settings, "VkBool32", "conservativePointAndLineRasterization", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.degenerateTrianglesRasterized, settings, "VkBool32", "degenerateTrianglesRasterized", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.degenerateLinesRasterized, settings, "VkBool32", "degenerateLinesRasterized", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fullyCoveredFragmentShaderInputVariable, settings, "VkBool32", "fullyCoveredFragmentShaderInputVariable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.conservativeRasterizationPostDepthCoverage, settings, "VkBool32", "conservativeRasterizationPostDepthCoverage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRasterizationConservativeStateCreateFlagsEXT<Format>(object.flags, settings, "VkPipelineRasterizationConservativeStateCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkConservativeRasterizationModeEXT<Format>(object.conservativeRasterizationMode, settings, "VkConservativeRasterizationModeEXT", "conservativeRasterizationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.extraPrimitiveOverestimationSize, settings, "float", "extraPrimitiveOverestimationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthClipEnable, settings, "VkBool32", "depthClipEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineRasterizationDepthClipStateCreateFlagsEXT<Format>(object.flags, settings, "VkPipelineRasterizationDepthClipStateCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthClipEnable, settings, "VkBool32", "depthClipEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkXYColorEXT(const VkXYColorEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, float>(object.x, settings, "float", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.y, settings, "float", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkHdrMetadataEXT(const VkHdrMetadataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkXYColorEXT<Format>(object.displayPrimaryRed, settings, "VkXYColorEXT", "displayPrimaryRed", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkXYColorEXT<Format>(object.displayPrimaryGreen, settings, "VkXYColorEXT", "displayPrimaryGreen", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkXYColorEXT<Format>(object.displayPrimaryBlue, settings, "VkXYColorEXT", "displayPrimaryBlue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkXYColorEXT<Format>(object.whitePoint, settings, "VkXYColorEXT", "whitePoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxLuminance, settings, "float", "maxLuminance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.minLuminance, settings, "float", "minLuminance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxContentLightLevel, settings, "float", "maxContentLightLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxFrameAverageLightLevel, settings, "float", "maxFrameAverageLightLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.relaxedLineRasterization, settings, "VkBool32", "relaxedLineRasterization", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_IOS_MVK)
template <ApiDumpFormat Format>
void dump_VkIOSSurfaceCreateInfoMVK(const VkIOSSurfaceCreateInfoMVK& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIOSSurfaceCreateFlagsMVK<Format>(object.flags, settings, "VkIOSSurfaceCreateFlagsMVK", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pView, settings, "const void*", "pView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_IOS_MVK
#if defined(VK_USE_PLATFORM_MACOS_MVK)
template <ApiDumpFormat Format>
void dump_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMacOSSurfaceCreateFlagsMVK<Format>(object.flags, settings, "VkMacOSSurfaceCreateFlagsMVK", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pView, settings, "const void*", "pView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_MACOS_MVK
template <ApiDumpFormat Format>
void dump_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pLabelName, settings, "const char*", "pLabelName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.color, 4, settings, "float[4]", "color", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, float>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkObjectType<Format>(object.objectType, settings, "VkObjectType", "objectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_uint64_t_as_pointer<Format>(object.objectHandle, settings, "uint64_t", "objectHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pObjectName, settings, "const char*", "pObjectName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDebugUtilsMessengerCallbackDataFlagsEXT<Format>(object.flags, settings, "VkDebugUtilsMessengerCallbackDataFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pMessageIdName, settings, "const char*", "pMessageIdName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.messageIdNumber, settings, "int32_t", "messageIdNumber", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pMessage, settings, "const char*", "pMessage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueLabelCount, settings, "uint32_t", "queueLabelCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pQueueLabels, object.queueLabelCount, settings, "const VkDebugUtilsLabelEXT*", "pQueueLabels", "const VkDebugUtilsLabelEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDebugUtilsLabelEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cmdBufLabelCount, settings, "uint32_t", "cmdBufLabelCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCmdBufLabels, object.cmdBufLabelCount, settings, "const VkDebugUtilsLabelEXT*", "pCmdBufLabels", "const VkDebugUtilsLabelEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDebugUtilsLabelEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.objectCount, settings, "uint32_t", "objectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pObjects, object.objectCount, settings, "const VkDebugUtilsObjectNameInfoEXT*", "pObjects", "const VkDebugUtilsObjectNameInfoEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDebugUtilsObjectNameInfoEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDebugUtilsMessengerCreateFlagsEXT<Format>(object.flags, settings, "VkDebugUtilsMessengerCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDebugUtilsMessageSeverityFlagsEXT<Format>(object.messageSeverity, settings, "VkDebugUtilsMessageSeverityFlagsEXT", "messageSeverity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDebugUtilsMessageTypeFlagsEXT<Format>(object.messageType, settings, "VkDebugUtilsMessageTypeFlagsEXT", "messageType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_PFN_vkDebugUtilsMessengerCallbackEXT<Format>(object.pfnUserCallback, settings, "PFN_vkDebugUtilsMessengerCallbackEXT", "pfnUserCallback", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pUserData, settings, "void*", "pUserData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkObjectType<Format>(object.objectType, settings, "VkObjectType", "objectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_uint64_t_as_pointer<Format>(object.objectHandle, settings, "uint64_t", "objectHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.tagName, settings, "uint64_t", "tagName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.tagSize, settings, "size_t", "tagSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pTag, settings, "const void*", "pTag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
template <ApiDumpFormat Format>
void dump_VkAndroidHardwareBufferUsageANDROID(const VkAndroidHardwareBufferUsageANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.androidHardwareBufferUsage, settings, "uint64_t", "androidHardwareBufferUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAndroidHardwareBufferPropertiesANDROID(const VkAndroidHardwareBufferPropertiesANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.allocationSize, settings, "VkDeviceSize", "allocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAndroidHardwareBufferFormatPropertiesANDROID(const VkAndroidHardwareBufferFormatPropertiesANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags<Format>(object.formatFeatures, settings, "VkFormatFeatureFlags", "formatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentMapping<Format>(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrModelConversion<Format>(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrRange<Format>(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImportAndroidHardwareBufferInfoANDROID(const VkImportAndroidHardwareBufferInfoANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, struct AHardwareBuffer*>(object.buffer, settings, "struct AHardwareBuffer*", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryGetAndroidHardwareBufferInfoANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalFormatANDROID(const VkExternalFormatANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAndroidHardwareBufferFormatProperties2ANDROID(const VkAndroidHardwareBufferFormatProperties2ANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.formatFeatures, settings, "VkFormatFeatureFlags2", "formatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentMapping<Format>(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrModelConversion<Format>(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrRange<Format>(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_ANDROID_KHR
template <ApiDumpFormat Format>
void dump_VkGpaPerfBlockPropertiesAMD(const VkGpaPerfBlockPropertiesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkGpaPerfBlockAMD<Format>(object.blockType, settings, "VkGpaPerfBlockAMD", "blockType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGpaPerfBlockPropertiesFlagsAMD<Format>(object.flags, settings, "VkGpaPerfBlockPropertiesFlagsAMD", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceCount, settings, "uint32_t", "instanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxEventID, settings, "uint32_t", "maxEventID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGlobalOnlyCounters, settings, "uint32_t", "maxGlobalOnlyCounters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGlobalSharedCounters, settings, "uint32_t", "maxGlobalSharedCounters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxStreamingCounters, settings, "uint32_t", "maxStreamingCounters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceGpaFeaturesAMD(const VkPhysicalDeviceGpaFeaturesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.perfCounters, settings, "VkBool32", "perfCounters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.streamingPerfCounters, settings, "VkBool32", "streamingPerfCounters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sqThreadTracing, settings, "VkBool32", "sqThreadTracing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.clockModes, settings, "VkBool32", "clockModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceGpaPropertiesAMD(const VkPhysicalDeviceGpaPropertiesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceGpaPropertiesFlagsAMD<Format>(object.flags, settings, "VkPhysicalDeviceGpaPropertiesFlagsAMD", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxSqttSeBufferSize, settings, "VkDeviceSize", "maxSqttSeBufferSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderEngineCount, settings, "uint32_t", "shaderEngineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.perfBlockCount, settings, "uint32_t", "perfBlockCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPerfBlocks, object.perfBlockCount, settings, "VkGpaPerfBlockPropertiesAMD*", "pPerfBlocks", "VkGpaPerfBlockPropertiesAMD", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkGpaPerfBlockPropertiesAMD<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceGpaProperties2AMD(const VkPhysicalDeviceGpaProperties2AMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.revisionId, settings, "uint32_t", "revisionId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGpaPerfCounterAMD(const VkGpaPerfCounterAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkGpaPerfBlockAMD<Format>(object.blockType, settings, "VkGpaPerfBlockAMD", "blockType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.blockInstance, settings, "uint32_t", "blockInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.eventID, settings, "uint32_t", "eventID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGpaSampleBeginInfoAMD(const VkGpaSampleBeginInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGpaSampleTypeAMD<Format>(object.sampleType, settings, "VkGpaSampleTypeAMD", "sampleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sampleInternalOperations, settings, "VkBool32", "sampleInternalOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cacheFlushOnCounterCollection, settings, "VkBool32", "cacheFlushOnCounterCollection", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sqShaderMaskEnable, settings, "VkBool32", "sqShaderMaskEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGpaSqShaderStageFlagsAMD<Format>(object.sqShaderMask, settings, "VkGpaSqShaderStageFlagsAMD", "sqShaderMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.perfCounterCount, settings, "uint32_t", "perfCounterCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPerfCounters, object.perfCounterCount, settings, "const VkGpaPerfCounterAMD*", "pPerfCounters", "const VkGpaPerfCounterAMD", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkGpaPerfCounterAMD<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.streamingPerfTraceSampleInterval, settings, "uint32_t", "streamingPerfTraceSampleInterval", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.perfCounterDeviceMemoryLimit, settings, "VkDeviceSize", "perfCounterDeviceMemoryLimit", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sqThreadTraceEnable, settings, "VkBool32", "sqThreadTraceEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sqThreadTraceSuppressInstructionTokens, settings, "VkBool32", "sqThreadTraceSuppressInstructionTokens", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.sqThreadTraceDeviceMemoryLimit, settings, "VkDeviceSize", "sqThreadTraceDeviceMemoryLimit", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags<Format>(object.timingPreSample, settings, "VkPipelineStageFlags", "timingPreSample", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags<Format>(object.timingPostSample, settings, "VkPipelineStageFlags", "timingPostSample", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGpaDeviceClockModeInfoAMD(const VkGpaDeviceClockModeInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGpaDeviceClockModeAMD<Format>(object.clockMode, settings, "VkGpaDeviceClockModeAMD", "clockMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.memoryClockRatioToPeak, settings, "float", "memoryClockRatioToPeak", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.engineClockRatioToPeak, settings, "float", "engineClockRatioToPeak", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGpaDeviceGetClockInfoAMD(const VkGpaDeviceGetClockInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.memoryClockRatioToPeak, settings, "float", "memoryClockRatioToPeak", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.engineClockRatioToPeak, settings, "float", "engineClockRatioToPeak", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryClockFrequency, settings, "uint32_t", "memoryClockFrequency", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.engineClockFrequency, settings, "uint32_t", "engineClockFrequency", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGpaSessionCreateInfoAMD(const VkGpaSessionCreateInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGpaSessionAMD<Format>(object.secondaryCopySource, settings, "VkGpaSessionAMD", "secondaryCopySource", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderEnqueue, settings, "VkBool32", "shaderEnqueue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderMeshEnqueue, settings, "VkBool32", "shaderMeshEnqueue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxExecutionGraphDepth, settings, "uint32_t", "maxExecutionGraphDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxExecutionGraphShaderOutputNodes, settings, "uint32_t", "maxExecutionGraphShaderOutputNodes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxExecutionGraphShaderPayloadSize, settings, "uint32_t", "maxExecutionGraphShaderPayloadSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxExecutionGraphShaderPayloadCount, settings, "uint32_t", "maxExecutionGraphShaderPayloadCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.executionGraphDispatchAddressAlignment, settings, "uint32_t", "executionGraphDispatchAddressAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxExecutionGraphWorkgroupCount, 3, settings, "uint32_t[3]", "maxExecutionGraphWorkgroupCount", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxExecutionGraphWorkgroups, settings, "uint32_t", "maxExecutionGraphWorkgroups", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExecutionGraphPipelineScratchSizeAMDX(const VkExecutionGraphPipelineScratchSizeAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.minSize, settings, "VkDeviceSize", "minSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxSize, settings, "VkDeviceSize", "maxSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.sizeGranularity, settings, "VkDeviceSize", "sizeGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExecutionGraphPipelineCreateInfoAMDX(const VkExecutionGraphPipelineCreateInfoAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCreateFlags<Format>(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stageCount, settings, "uint32_t", "stageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pLibraryInfo, settings, "const VkPipelineLibraryCreateInfoKHR*", "pLibraryInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineLibraryCreateInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceOrHostAddressConstAMDX(const VkDeviceOrHostAddressConstAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.hostAddress, settings, "const void*", "hostAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDispatchGraphInfoAMDX(const VkDispatchGraphInfoAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.nodeIndex, settings, "uint32_t", "nodeIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.payloadCount, settings, "uint32_t", "payloadCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstAMDX<Format>(object.payloads, settings, "VkDeviceOrHostAddressConstAMDX", "payloads", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.payloadStride, settings, "uint64_t", "payloadStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDispatchGraphCountInfoAMDX(const VkDispatchGraphCountInfoAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.count, settings, "uint32_t", "count", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstAMDX<Format>(object.infos, settings, "VkDeviceOrHostAddressConstAMDX", "infos", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.stride, settings, "uint64_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineShaderStageNodeCreateInfoAMDX(const VkPipelineShaderStageNodeCreateInfoAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_ENABLE_BETA_EXTENSIONS
template <ApiDumpFormat Format>
void dump_VkHostAddressRangeEXT(const VkHostAddressRangeEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, void*>(object.address, settings, "void*", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.size, settings, "size_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkHostAddressRangeConstEXT(const VkHostAddressRangeConstEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, const void*>(object.address, settings, "const void*", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.size, settings, "size_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTexelBufferDescriptorInfoEXT(const VkTexelBufferDescriptorInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.addressRange, settings, "VkDeviceAddressRangeEXT", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageDescriptorInfoEXT(const VkImageDescriptorInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pView, settings, "const VkImageViewCreateInfo*", "pView", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageViewCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.layout, settings, "VkImageLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorViewCreateInfoARM(const VkTensorViewCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorViewCreateFlagsARM<Format>(object.flags, settings, "VkTensorViewCreateFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorARM<Format>(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkResourceDescriptorDataEXT(const VkResourceDescriptorDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) {
        dump_pointer<Format>(object.pImage, settings, "const VkImageDescriptorInfoEXT*", "pImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageDescriptorInfoEXT<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) {
        dump_pointer<Format>(object.pTexelBuffer, settings, "const VkTexelBufferDescriptorInfoEXT*", "pTexelBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTexelBufferDescriptorInfoEXT<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV) {
        dump_pointer<Format>(object.pAddressRange, settings, "const VkDeviceAddressRangeEXT*", "pAddressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceAddressRangeKHR<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_TENSOR_ARM) {
        dump_pointer<Format>(object.pTensorARM, settings, "const VkTensorViewCreateInfoARM*", "pTensorARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorViewCreateInfoARM<Format>);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkResourceDescriptorInfoEXT(const VkResourceDescriptorInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    ApiDumpInstance::current().setDescriptorType(object.type);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorType<Format>(object.type, settings, "VkDescriptorType", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkResourceDescriptorDataEXT<Format>(object.data, settings, "VkResourceDescriptorDataEXT", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindHeapInfoEXT(const VkBindHeapInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressRangeKHR<Format>(object.heapRange, settings, "VkDeviceAddressRangeEXT", "heapRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.reservedRangeOffset, settings, "VkDeviceSize", "reservedRangeOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.reservedRangeSize, settings, "VkDeviceSize", "reservedRangeSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPushDataInfoEXT(const VkPushDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkHostAddressRangeConstEXT<Format>(object.data, settings, "VkHostAddressRangeConstEXT", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorMappingSourceConstantOffsetEXT(const VkDescriptorMappingSourceConstantOffsetEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.heapArrayStride, settings, "uint32_t", "heapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pEmbeddedSampler, settings, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapOffset, settings, "uint32_t", "samplerHeapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapArrayStride, settings, "uint32_t", "samplerHeapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorMappingSourcePushIndexEXT(const VkDescriptorMappingSourcePushIndexEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pushOffset, settings, "uint32_t", "pushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.heapIndexStride, settings, "uint32_t", "heapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.heapArrayStride, settings, "uint32_t", "heapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pEmbeddedSampler, settings, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useCombinedImageSamplerIndex, settings, "VkBool32", "useCombinedImageSamplerIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapOffset, settings, "uint32_t", "samplerHeapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerPushOffset, settings, "uint32_t", "samplerPushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapIndexStride, settings, "uint32_t", "samplerHeapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapArrayStride, settings, "uint32_t", "samplerHeapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorMappingSourceIndirectIndexEXT(const VkDescriptorMappingSourceIndirectIndexEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pushOffset, settings, "uint32_t", "pushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.addressOffset, settings, "uint32_t", "addressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.heapIndexStride, settings, "uint32_t", "heapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.heapArrayStride, settings, "uint32_t", "heapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pEmbeddedSampler, settings, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useCombinedImageSamplerIndex, settings, "VkBool32", "useCombinedImageSamplerIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapOffset, settings, "uint32_t", "samplerHeapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerPushOffset, settings, "uint32_t", "samplerPushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerAddressOffset, settings, "uint32_t", "samplerAddressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapIndexStride, settings, "uint32_t", "samplerHeapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapArrayStride, settings, "uint32_t", "samplerHeapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorMappingSourceHeapDataEXT(const VkDescriptorMappingSourceHeapDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pushOffset, settings, "uint32_t", "pushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorMappingSourceIndirectAddressEXT(const VkDescriptorMappingSourceIndirectAddressEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.pushOffset, settings, "uint32_t", "pushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.addressOffset, settings, "uint32_t", "addressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorMappingSourceShaderRecordIndexEXT(const VkDescriptorMappingSourceShaderRecordIndexEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderRecordOffset, settings, "uint32_t", "shaderRecordOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.heapIndexStride, settings, "uint32_t", "heapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.heapArrayStride, settings, "uint32_t", "heapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pEmbeddedSampler, settings, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useCombinedImageSamplerIndex, settings, "VkBool32", "useCombinedImageSamplerIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapOffset, settings, "uint32_t", "samplerHeapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerShaderRecordOffset, settings, "uint32_t", "samplerShaderRecordOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapIndexStride, settings, "uint32_t", "samplerHeapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapArrayStride, settings, "uint32_t", "samplerHeapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorMappingSourceIndirectIndexArrayEXT(const VkDescriptorMappingSourceIndirectIndexArrayEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pushOffset, settings, "uint32_t", "pushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.addressOffset, settings, "uint32_t", "addressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.heapIndexStride, settings, "uint32_t", "heapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pEmbeddedSampler, settings, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.useCombinedImageSamplerIndex, settings, "VkBool32", "useCombinedImageSamplerIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapOffset, settings, "uint32_t", "samplerHeapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerPushOffset, settings, "uint32_t", "samplerPushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerAddressOffset, settings, "uint32_t", "samplerAddressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerHeapIndexStride, settings, "uint32_t", "samplerHeapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorMappingSourceDataEXT(const VkDescriptorMappingSourceDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT) {
        dump_VkDescriptorMappingSourceConstantOffsetEXT<Format>(object.constantOffset, settings, "VkDescriptorMappingSourceConstantOffsetEXT", "constantOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT) {
        dump_VkDescriptorMappingSourcePushIndexEXT<Format>(object.pushIndex, settings, "VkDescriptorMappingSourcePushIndexEXT", "pushIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT) {
        dump_VkDescriptorMappingSourceIndirectIndexEXT<Format>(object.indirectIndex, settings, "VkDescriptorMappingSourceIndirectIndexEXT", "indirectIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT) {
        dump_VkDescriptorMappingSourceIndirectIndexArrayEXT<Format>(object.indirectIndexArray, settings, "VkDescriptorMappingSourceIndirectIndexArrayEXT", "indirectIndexArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT) {
        dump_VkDescriptorMappingSourceHeapDataEXT<Format>(object.heapData, settings, "VkDescriptorMappingSourceHeapDataEXT", "heapData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT) {
        dump_type<Format, uint32_t>(object.pushDataOffset, settings, "uint32_t", "pushDataOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT) {
        dump_type<Format, uint32_t>(object.pushAddressOffset, settings, "uint32_t", "pushAddressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT) {
        dump_VkDescriptorMappingSourceIndirectAddressEXT<Format>(object.indirectAddress, settings, "VkDescriptorMappingSourceIndirectAddressEXT", "indirectAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT) {
        dump_VkDescriptorMappingSourceShaderRecordIndexEXT<Format>(object.shaderRecordIndex, settings, "VkDescriptorMappingSourceShaderRecordIndexEXT", "shaderRecordIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT) {
        dump_type<Format, uint32_t>(object.shaderRecordDataOffset, settings, "uint32_t", "shaderRecordDataOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT) {
        dump_type<Format, uint32_t>(object.shaderRecordAddressOffset, settings, "uint32_t", "shaderRecordAddressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorSetAndBindingMappingEXT(const VkDescriptorSetAndBindingMappingEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    ApiDumpInstance::current().setDescriptorMappingSource(object.source);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorSet, settings, "uint32_t", "descriptorSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.firstBinding, settings, "uint32_t", "firstBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bindingCount, settings, "uint32_t", "bindingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSpirvResourceTypeFlagsEXT<Format>(object.resourceMask, settings, "VkSpirvResourceTypeFlagsEXT", "resourceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorMappingSourceEXT<Format>(object.source, settings, "VkDescriptorMappingSourceEXT", "source", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorMappingSourceDataEXT<Format>(object.sourceData, settings, "VkDescriptorMappingSourceDataEXT", "sourceData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderDescriptorSetAndBindingMappingInfoEXT(const VkShaderDescriptorSetAndBindingMappingInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.mappingCount, settings, "uint32_t", "mappingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pMappings, object.mappingCount, settings, "const VkDescriptorSetAndBindingMappingEXT*", "pMappings", "const VkDescriptorSetAndBindingMappingEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetAndBindingMappingEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkOpaqueCaptureDataCreateInfoEXT(const VkOpaqueCaptureDataCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pData, settings, "const VkHostAddressRangeConstEXT*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkHostAddressRangeConstEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorHeapFeaturesEXT(const VkPhysicalDeviceDescriptorHeapFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorHeap, settings, "VkBool32", "descriptorHeap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorHeapCaptureReplay, settings, "VkBool32", "descriptorHeapCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorHeapPropertiesEXT(const VkPhysicalDeviceDescriptorHeapPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.samplerHeapAlignment, settings, "VkDeviceSize", "samplerHeapAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.resourceHeapAlignment, settings, "VkDeviceSize", "resourceHeapAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxSamplerHeapSize, settings, "VkDeviceSize", "maxSamplerHeapSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxResourceHeapSize, settings, "VkDeviceSize", "maxResourceHeapSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.minSamplerHeapReservedRange, settings, "VkDeviceSize", "minSamplerHeapReservedRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.minSamplerHeapReservedRangeWithEmbedded, settings, "VkDeviceSize", "minSamplerHeapReservedRangeWithEmbedded", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.minResourceHeapReservedRange, settings, "VkDeviceSize", "minResourceHeapReservedRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.samplerDescriptorSize, settings, "VkDeviceSize", "samplerDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.imageDescriptorSize, settings, "VkDeviceSize", "imageDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.bufferDescriptorSize, settings, "VkDeviceSize", "bufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.samplerDescriptorAlignment, settings, "VkDeviceSize", "samplerDescriptorAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.imageDescriptorAlignment, settings, "VkDeviceSize", "imageDescriptorAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.bufferDescriptorAlignment, settings, "VkDeviceSize", "bufferDescriptorAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxPushDataSize, settings, "VkDeviceSize", "maxPushDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.imageCaptureReplayOpaqueDataSize, settings, "size_t", "imageCaptureReplayOpaqueDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorHeapEmbeddedSamplers, settings, "uint32_t", "maxDescriptorHeapEmbeddedSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.samplerYcbcrConversionCount, settings, "uint32_t", "samplerYcbcrConversionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseDescriptorHeaps, settings, "VkBool32", "sparseDescriptorHeaps", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.protectedDescriptorHeaps, settings, "VkBool32", "protectedDescriptorHeaps", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferInheritanceDescriptorHeapInfoEXT(const VkCommandBufferInheritanceDescriptorHeapInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSamplerHeapBindInfo, settings, "const VkBindHeapInfoEXT*", "pSamplerHeapBindInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBindHeapInfoEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pResourceHeapBindInfo, settings, "const VkBindHeapInfoEXT*", "pResourceHeapBindInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBindHeapInfoEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerCustomBorderColorIndexCreateInfoEXT(const VkSamplerCustomBorderColorIndexCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClearColorValue<Format>(object.customBorderColor, settings, "VkClearColorValue", "customBorderColor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsLayoutPushDataTokenNV(const VkIndirectCommandsLayoutPushDataTokenNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pushDataOffset, settings, "uint32_t", "pushDataOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pushDataSize, settings, "uint32_t", "pushDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubsampledImageFormatPropertiesEXT(const VkSubsampledImageFormatPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subsampledImageDescriptorCount, settings, "uint32_t", "subsampledImageDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorHeapTensorPropertiesARM(const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.tensorDescriptorSize, settings, "VkDeviceSize", "tensorDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.tensorDescriptorAlignment, settings, "VkDeviceSize", "tensorDescriptorAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.tensorCaptureReplayOpaqueDataSize, settings, "size_t", "tensorCaptureReplayOpaqueDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pColorAttachmentSamples, object.colorAttachmentCount, settings, "const VkSampleCountFlagBits*", "pColorAttachmentSamples", "const VkSampleCountFlagBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSampleCountFlagBits<Format>);
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.depthStencilAttachmentSamples, settings, "VkSampleCountFlagBits", "depthStencilAttachmentSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSampleLocationEXT(const VkSampleLocationEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, float>(object.x, settings, "float", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.y, settings, "float", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.sampleLocationsPerPixel, settings, "VkSampleCountFlagBits", "sampleLocationsPerPixel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.sampleLocationGridSize, settings, "VkExtent2D", "sampleLocationGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sampleLocationsCount, settings, "uint32_t", "sampleLocationsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSampleLocations, object.sampleLocationsCount, settings, "const VkSampleLocationEXT*", "pSampleLocations", "const VkSampleLocationEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSampleLocationEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.attachmentIndex, settings, "uint32_t", "attachmentIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleLocationsInfoEXT<Format>(object.sampleLocationsInfo, settings, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.subpassIndex, settings, "uint32_t", "subpassIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleLocationsInfoEXT<Format>(object.sampleLocationsInfo, settings, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.attachmentInitialSampleLocationsCount, settings, "uint32_t", "attachmentInitialSampleLocationsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAttachmentInitialSampleLocations, object.attachmentInitialSampleLocationsCount, settings, "const VkAttachmentSampleLocationsEXT*", "pAttachmentInitialSampleLocations", "const VkAttachmentSampleLocationsEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentSampleLocationsEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.postSubpassSampleLocationsCount, settings, "uint32_t", "postSubpassSampleLocationsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPostSubpassSampleLocations, object.postSubpassSampleLocationsCount, settings, "const VkSubpassSampleLocationsEXT*", "pPostSubpassSampleLocations", "const VkSubpassSampleLocationsEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassSampleLocationsEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sampleLocationsEnable, settings, "VkBool32", "sampleLocationsEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleLocationsInfoEXT<Format>(object.sampleLocationsInfo, settings, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.sampleLocationSampleCounts, settings, "VkSampleCountFlags", "sampleLocationSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxSampleLocationGridSize, settings, "VkExtent2D", "maxSampleLocationGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.sampleLocationCoordinateRange, 2, settings, "float[2]", "sampleLocationCoordinateRange", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, float>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sampleLocationSubPixelBits, settings, "uint32_t", "sampleLocationSubPixelBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.variableSampleLocations, settings, "VkBool32", "variableSampleLocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxSampleLocationGridSize, settings, "VkExtent2D", "maxSampleLocationGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.advancedBlendCoherentOperations, settings, "VkBool32", "advancedBlendCoherentOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.advancedBlendMaxColorAttachments, settings, "uint32_t", "advancedBlendMaxColorAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.advancedBlendIndependentBlend, settings, "VkBool32", "advancedBlendIndependentBlend", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.advancedBlendNonPremultipliedSrcColor, settings, "VkBool32", "advancedBlendNonPremultipliedSrcColor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.advancedBlendNonPremultipliedDstColor, settings, "VkBool32", "advancedBlendNonPremultipliedDstColor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.advancedBlendCorrelatedOverlap, settings, "VkBool32", "advancedBlendCorrelatedOverlap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.advancedBlendAllOperations, settings, "VkBool32", "advancedBlendAllOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.srcPremultiplied, settings, "VkBool32", "srcPremultiplied", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dstPremultiplied, settings, "VkBool32", "dstPremultiplied", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendOverlapEXT<Format>(object.blendOverlap, settings, "VkBlendOverlapEXT", "blendOverlap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCoverageToColorStateCreateFlagsNV<Format>(object.flags, settings, "VkPipelineCoverageToColorStateCreateFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.coverageToColorEnable, settings, "VkBool32", "coverageToColorEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.coverageToColorLocation, settings, "uint32_t", "coverageToColorLocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCoverageModulationStateCreateFlagsNV<Format>(object.flags, settings, "VkPipelineCoverageModulationStateCreateFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCoverageModulationModeNV<Format>(object.coverageModulationMode, settings, "VkCoverageModulationModeNV", "coverageModulationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.coverageModulationTableEnable, settings, "VkBool32", "coverageModulationTableEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.coverageModulationTableCount, settings, "uint32_t", "coverageModulationTableCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCoverageModulationTable, object.coverageModulationTableCount, settings, "const float*", "pCoverageModulationTable", "const float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const float>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderSMCount, settings, "uint32_t", "shaderSMCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderWarpsPerSM, settings, "uint32_t", "shaderWarpsPerSM", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSMBuiltins, settings, "VkBool32", "shaderSMBuiltins", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint64_t>(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.drmFormatModifierPlaneCount, settings, "uint32_t", "drmFormatModifierPlaneCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags<Format>(object.drmFormatModifierTilingFeatures, settings, "VkFormatFeatureFlags", "drmFormatModifierTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.drmFormatModifierCount, settings, "uint32_t", "drmFormatModifierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDrmFormatModifierProperties, object.drmFormatModifierCount, settings, "VkDrmFormatModifierPropertiesEXT*", "pDrmFormatModifierProperties", "VkDrmFormatModifierPropertiesEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDrmFormatModifierPropertiesEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSharingMode<Format>(object.sharingMode, settings, "VkSharingMode", "sharingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.drmFormatModifierCount, settings, "uint32_t", "drmFormatModifierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDrmFormatModifiers, object.drmFormatModifierCount, settings, "const uint64_t*", "pDrmFormatModifiers", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.drmFormatModifierPlaneCount, settings, "uint32_t", "drmFormatModifierPlaneCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPlaneLayouts, object.drmFormatModifierPlaneCount, settings, "const VkSubresourceLayout*", "pPlaneLayouts", "const VkSubresourceLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubresourceLayout<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint64_t>(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.drmFormatModifierPlaneCount, settings, "uint32_t", "drmFormatModifierPlaneCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.drmFormatModifierTilingFeatures, settings, "VkFormatFeatureFlags2", "drmFormatModifierTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.drmFormatModifierCount, settings, "uint32_t", "drmFormatModifierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDrmFormatModifierProperties, object.drmFormatModifierCount, settings, "VkDrmFormatModifierProperties2EXT*", "pDrmFormatModifierProperties", "VkDrmFormatModifierProperties2EXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDrmFormatModifierProperties2EXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkValidationCacheCreateFlagsEXT<Format>(object.flags, settings, "VkValidationCacheCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.initialDataSize, settings, "size_t", "initialDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pInitialData, settings, "const void*", "pInitialData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderModuleValidationCacheCreateInfoEXT(const VkShaderModuleValidationCacheCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkValidationCacheEXT<Format>(object.validationCache, settings, "VkValidationCacheEXT", "validationCache", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkShadingRatePaletteNV(const VkShadingRatePaletteNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.shadingRatePaletteEntryCount, settings, "uint32_t", "shadingRatePaletteEntryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pShadingRatePaletteEntries, object.shadingRatePaletteEntryCount, settings, "const VkShadingRatePaletteEntryNV*", "pShadingRatePaletteEntries", "const VkShadingRatePaletteEntryNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkShadingRatePaletteEntryNV<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineViewportShadingRateImageStateCreateInfoNV(const VkPipelineViewportShadingRateImageStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shadingRateImageEnable, settings, "VkBool32", "shadingRateImageEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewportCount, settings, "uint32_t", "viewportCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pShadingRatePalettes, object.viewportCount, settings, "const VkShadingRatePaletteNV*", "pShadingRatePalettes", "const VkShadingRatePaletteNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkShadingRatePaletteNV<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShadingRateImageFeaturesNV(const VkPhysicalDeviceShadingRateImageFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shadingRateImage, settings, "VkBool32", "shadingRateImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shadingRateCoarseSampleOrder, settings, "VkBool32", "shadingRateCoarseSampleOrder", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShadingRateImagePropertiesNV(const VkPhysicalDeviceShadingRateImagePropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.shadingRateTexelSize, settings, "VkExtent2D", "shadingRateTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shadingRatePaletteSize, settings, "uint32_t", "shadingRatePaletteSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shadingRateMaxCoarseSamples, settings, "uint32_t", "shadingRateMaxCoarseSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCoarseSampleLocationNV(const VkCoarseSampleLocationNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.pixelX, settings, "uint32_t", "pixelX", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pixelY, settings, "uint32_t", "pixelY", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sample, settings, "uint32_t", "sample", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkShadingRatePaletteEntryNV<Format>(object.shadingRate, settings, "VkShadingRatePaletteEntryNV", "shadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sampleCount, settings, "uint32_t", "sampleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sampleLocationCount, settings, "uint32_t", "sampleLocationCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSampleLocations, object.sampleLocationCount, settings, "const VkCoarseSampleLocationNV*", "pSampleLocations", "const VkCoarseSampleLocationNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkCoarseSampleLocationNV<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCoarseSampleOrderTypeNV<Format>(object.sampleOrderType, settings, "VkCoarseSampleOrderTypeNV", "sampleOrderType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.customSampleOrderCount, settings, "uint32_t", "customSampleOrderCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCustomSampleOrders, object.customSampleOrderCount, settings, "const VkCoarseSampleOrderCustomNV*", "pCustomSampleOrders", "const VkCoarseSampleOrderCustomNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkCoarseSampleOrderCustomNV<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRayTracingShaderGroupCreateInfoNV(const VkRayTracingShaderGroupCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRayTracingShaderGroupTypeKHR<Format>(object.type, settings, "VkRayTracingShaderGroupTypeKHR", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.generalShader, settings, "uint32_t", "generalShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.closestHitShader, settings, "uint32_t", "closestHitShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.anyHitShader, settings, "uint32_t", "anyHitShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.intersectionShader, settings, "uint32_t", "intersectionShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCreateFlags<Format>(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stageCount, settings, "uint32_t", "stageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.groupCount, settings, "uint32_t", "groupCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pGroups, object.groupCount, settings, "const VkRayTracingShaderGroupCreateInfoNV*", "pGroups", "const VkRayTracingShaderGroupCreateInfoNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRayTracingShaderGroupCreateInfoNV<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxRecursionDepth, settings, "uint32_t", "maxRecursionDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeometryTrianglesNV(const VkGeometryTrianglesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.vertexData, settings, "VkBuffer", "vertexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.vertexOffset, settings, "VkDeviceSize", "vertexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vertexCount, settings, "uint32_t", "vertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.indexData, settings, "VkBuffer", "indexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.indexOffset, settings, "VkDeviceSize", "indexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.indexCount, settings, "uint32_t", "indexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndexType<Format>(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.transformData, settings, "VkBuffer", "transformData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.transformOffset, settings, "VkDeviceSize", "transformOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeometryAABBNV(const VkGeometryAABBNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.aabbData, settings, "VkBuffer", "aabbData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numAABBs, settings, "uint32_t", "numAABBs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeometryDataNV(const VkGeometryDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkGeometryTrianglesNV<Format>(object.triangles, settings, "VkGeometryTrianglesNV", "triangles", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGeometryAABBNV<Format>(object.aabbs, settings, "VkGeometryAABBNV", "aabbs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeometryNV(const VkGeometryNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGeometryTypeKHR<Format>(object.geometryType, settings, "VkGeometryTypeKHR", "geometryType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGeometryDataNV<Format>(object.geometry, settings, "VkGeometryDataNV", "geometry", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGeometryFlagsKHR<Format>(object.flags, settings, "VkGeometryFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureTypeKHR<Format>(object.type, settings, "VkAccelerationStructureTypeNV", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuildAccelerationStructureFlagsKHR<Format>(object.flags, settings, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceCount, settings, "uint32_t", "instanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.geometryCount, settings, "uint32_t", "geometryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pGeometries, object.geometryCount, settings, "const VkGeometryNV*", "pGeometries", "const VkGeometryNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkGeometryNV<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureCreateInfoNV(const VkAccelerationStructureCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.compactedSize, settings, "VkDeviceSize", "compactedSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureInfoNV<Format>(object.info, settings, "VkAccelerationStructureInfoNV", "info", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindAccelerationStructureMemoryInfoNV(const VkBindAccelerationStructureMemoryInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureNV<Format>(object.accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceIndexCount, settings, "uint32_t", "deviceIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDeviceIndices, object.deviceIndexCount, settings, "const uint32_t*", "pDeviceIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkWriteDescriptorSetAccelerationStructureNV(const VkWriteDescriptorSetAccelerationStructureNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAccelerationStructures, object.accelerationStructureCount, settings, "const VkAccelerationStructureNV*", "pAccelerationStructures", "const VkAccelerationStructureNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureNV<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureMemoryRequirementsInfoNV(const VkAccelerationStructureMemoryRequirementsInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureMemoryRequirementsTypeNV<Format>(object.type, settings, "VkAccelerationStructureMemoryRequirementsTypeNV", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureNV<Format>(object.accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingPropertiesNV(const VkPhysicalDeviceRayTracingPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderGroupHandleSize, settings, "uint32_t", "shaderGroupHandleSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxRecursionDepth, settings, "uint32_t", "maxRecursionDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxShaderGroupStride, settings, "uint32_t", "maxShaderGroupStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderGroupBaseAlignment, settings, "uint32_t", "shaderGroupBaseAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxGeometryCount, settings, "uint64_t", "maxGeometryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxInstanceCount, settings, "uint64_t", "maxInstanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxTriangleCount, settings, "uint64_t", "maxTriangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetAccelerationStructures, settings, "uint32_t", "maxDescriptorSetAccelerationStructures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTransformMatrixKHR(const VkTransformMatrixKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_double_array<Format>(object.matrix, 3, 4, settings, "float[3][4]", "matrix", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, float>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAabbPositionsKHR(const VkAabbPositionsKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, float>(object.minX, settings, "float", "minX", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.minY, settings, "float", "minY", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.minZ, settings, "float", "minZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxX, settings, "float", "maxX", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxY, settings, "float", "maxY", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxZ, settings, "float", "maxZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureInstanceKHR(const VkAccelerationStructureInstanceKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkTransformMatrixKHR<Format>(object.transform, settings, "VkTransformMatrixKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceCustomIndex, settings, "uint32_t:24", "instanceCustomIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.mask, settings, "uint32_t:8", "mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceShaderBindingTableRecordOffset, settings, "uint32_t:24", "instanceShaderBindingTableRecordOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGeometryInstanceFlagsKHR<Format>(object.flags, settings, "VkGeometryInstanceFlagsKHR:8", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.accelerationStructureReference, settings, "uint64_t", "accelerationStructureReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.representativeFragmentTest, settings, "VkBool32", "representativeFragmentTest", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.representativeFragmentTestEnable, settings, "VkBool32", "representativeFragmentTestEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageViewType<Format>(object.imageViewType, settings, "VkImageViewType", "imageViewType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.filterCubic, settings, "VkBool32", "filterCubic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.filterCubicMinmax, settings, "VkBool32", "filterCubicMinmax", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM(const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrixConversion, settings, "VkBool32", "cooperativeMatrixConversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM(const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.elapsedTimerQuery, settings, "VkBool32", "elapsedTimerQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pHostPointer, settings, "void*", "pHostPointer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.minImportedHostPointerAlignment, settings, "VkDeviceSize", "minImportedHostPointerAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCompilerControlCreateInfoAMD(const VkPipelineCompilerControlCreateInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCompilerControlFlagsAMD<Format>(object.compilerControlFlags, settings, "VkPipelineCompilerControlFlagsAMD", "compilerControlFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderCorePropertiesAMD(const VkPhysicalDeviceShaderCorePropertiesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderEngineCount, settings, "uint32_t", "shaderEngineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderArraysPerEngineCount, settings, "uint32_t", "shaderArraysPerEngineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.computeUnitsPerShaderArray, settings, "uint32_t", "computeUnitsPerShaderArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.simdPerComputeUnit, settings, "uint32_t", "simdPerComputeUnit", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.wavefrontsPerSimd, settings, "uint32_t", "wavefrontsPerSimd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.wavefrontSize, settings, "uint32_t", "wavefrontSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sgprsPerSimd, settings, "uint32_t", "sgprsPerSimd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minSgprAllocation, settings, "uint32_t", "minSgprAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSgprAllocation, settings, "uint32_t", "maxSgprAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sgprAllocationGranularity, settings, "uint32_t", "sgprAllocationGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vgprsPerSimd, settings, "uint32_t", "vgprsPerSimd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minVgprAllocation, settings, "uint32_t", "minVgprAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVgprAllocation, settings, "uint32_t", "maxVgprAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vgprAllocationGranularity, settings, "uint32_t", "vgprAllocationGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceMemoryOverallocationCreateInfoAMD(const VkDeviceMemoryOverallocationCreateInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMemoryOverallocationBehaviorAMD<Format>(object.overallocationBehavior, settings, "VkMemoryOverallocationBehaviorAMD", "overallocationBehavior", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVertexAttribDivisor, settings, "uint32_t", "maxVertexAttribDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_GGP)
template <ApiDumpFormat Format>
void dump_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, GgpFrameToken>(object.frameToken, settings, "GgpFrameToken", "frameToken", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_GGP
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMeshShaderFeaturesNV(const VkPhysicalDeviceMeshShaderFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.taskShader, settings, "VkBool32", "taskShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.meshShader, settings, "VkBool32", "meshShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMeshShaderPropertiesNV(const VkPhysicalDeviceMeshShaderPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDrawMeshTasksCount, settings, "uint32_t", "maxDrawMeshTasksCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTaskWorkGroupInvocations, settings, "uint32_t", "maxTaskWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxTaskWorkGroupSize, 3, settings, "uint32_t[3]", "maxTaskWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTaskTotalMemorySize, settings, "uint32_t", "maxTaskTotalMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTaskOutputCount, settings, "uint32_t", "maxTaskOutputCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshWorkGroupInvocations, settings, "uint32_t", "maxMeshWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxMeshWorkGroupSize, 3, settings, "uint32_t[3]", "maxMeshWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshTotalMemorySize, settings, "uint32_t", "maxMeshTotalMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshOutputVertices, settings, "uint32_t", "maxMeshOutputVertices", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshOutputPrimitives, settings, "uint32_t", "maxMeshOutputPrimitives", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshMultiviewViewCount, settings, "uint32_t", "maxMeshMultiviewViewCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.meshOutputPerVertexGranularity, settings, "uint32_t", "meshOutputPerVertexGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.meshOutputPerPrimitiveGranularity, settings, "uint32_t", "meshOutputPerPrimitiveGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDrawMeshTasksIndirectCommandNV(const VkDrawMeshTasksIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.taskCount, settings, "uint32_t", "taskCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.firstTask, settings, "uint32_t", "firstTask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const VkPhysicalDeviceShaderImageFootprintFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imageFootprint, settings, "VkBool32", "imageFootprint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const VkPipelineViewportExclusiveScissorStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.exclusiveScissorCount, settings, "uint32_t", "exclusiveScissorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pExclusiveScissors, object.exclusiveScissorCount, settings, "const VkRect2D*", "pExclusiveScissors", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExclusiveScissorFeaturesNV(const VkPhysicalDeviceExclusiveScissorFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.exclusiveScissor, settings, "VkBool32", "exclusiveScissor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyCheckpointPropertiesNV(const VkQueueFamilyCheckpointPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags<Format>(object.checkpointExecutionStageMask, settings, "VkPipelineStageFlags", "checkpointExecutionStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCheckpointDataNV(const VkCheckpointDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlagBits<Format>(object.stage, settings, "VkPipelineStageFlagBits", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pCheckpointMarker, settings, "void*", "pCheckpointMarker", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.checkpointExecutionStageMask, settings, "VkPipelineStageFlags2", "checkpointExecutionStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCheckpointData2NV(const VkCheckpointData2NV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.stage, settings, "VkPipelineStageFlags2", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pCheckpointMarker, settings, "void*", "pCheckpointMarker", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePresentTimingFeaturesEXT(const VkPhysicalDevicePresentTimingFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentTiming, settings, "VkBool32", "presentTiming", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentAtAbsoluteTime, settings, "VkBool32", "presentAtAbsoluteTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentAtRelativeTime, settings, "VkBool32", "presentAtRelativeTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentTimingSurfaceCapabilitiesEXT(const VkPresentTimingSurfaceCapabilitiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentTimingSupported, settings, "VkBool32", "presentTimingSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentAtAbsoluteTimeSupported, settings, "VkBool32", "presentAtAbsoluteTimeSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentAtRelativeTimeSupported, settings, "VkBool32", "presentAtRelativeTimeSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentStageFlagsEXT<Format>(object.presentStageQueries, settings, "VkPresentStageFlagsEXT", "presentStageQueries", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainCalibratedTimestampInfoEXT(const VkSwapchainCalibratedTimestampInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSwapchainKHR<Format>(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentStageFlagsEXT<Format>(object.presentStage, settings, "VkPresentStageFlagsEXT", "presentStage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.timeDomainId, settings, "uint64_t", "timeDomainId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainTimingPropertiesEXT(const VkSwapchainTimingPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.refreshDuration, settings, "uint64_t", "refreshDuration", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.refreshInterval, settings, "uint64_t", "refreshInterval", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainTimeDomainPropertiesEXT(const VkSwapchainTimeDomainPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.timeDomainCount, settings, "uint32_t", "timeDomainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTimeDomains, object.timeDomainCount, settings, "VkTimeDomainKHR*", "pTimeDomains", "VkTimeDomainKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTimeDomainKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTimeDomainIds, object.timeDomainCount, settings, "uint64_t*", "pTimeDomainIds", "uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint64_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPastPresentationTimingInfoEXT(const VkPastPresentationTimingInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPastPresentationTimingFlagsEXT<Format>(object.flags, settings, "VkPastPresentationTimingFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSwapchainKHR<Format>(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentStageTimeEXT(const VkPresentStageTimeEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkPresentStageFlagsEXT<Format>(object.stage, settings, "VkPresentStageFlagsEXT", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.time, settings, "uint64_t", "time", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPastPresentationTimingEXT(const VkPastPresentationTimingEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.presentId, settings, "uint64_t", "presentId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.targetTime, settings, "uint64_t", "targetTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.presentStageCount, settings, "uint32_t", "presentStageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPresentStages, object.presentStageCount, settings, "VkPresentStageTimeEXT*", "pPresentStages", "VkPresentStageTimeEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentStageTimeEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_VkTimeDomainKHR<Format>(object.timeDomain, settings, "VkTimeDomainKHR", "timeDomain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.timeDomainId, settings, "uint64_t", "timeDomainId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.reportComplete, settings, "VkBool32", "reportComplete", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPastPresentationTimingPropertiesEXT(const VkPastPresentationTimingPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.timingPropertiesCounter, settings, "uint64_t", "timingPropertiesCounter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.timeDomainsCounter, settings, "uint64_t", "timeDomainsCounter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.presentationTimingCount, settings, "uint32_t", "presentationTimingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPresentationTimings, object.presentationTimingCount, settings, "VkPastPresentationTimingEXT*", "pPresentationTimings", "VkPastPresentationTimingEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPastPresentationTimingEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentTimingInfoEXT(const VkPresentTimingInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentTimingInfoFlagsEXT<Format>(object.flags, settings, "VkPresentTimingInfoFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.targetTime, settings, "uint64_t", "targetTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.timeDomainId, settings, "uint64_t", "timeDomainId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentStageFlagsEXT<Format>(object.presentStageQueries, settings, "VkPresentStageFlagsEXT", "presentStageQueries", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPresentStageFlagsEXT<Format>(object.targetTimeDomainPresentStage, settings, "VkPresentStageFlagsEXT", "targetTimeDomainPresentStage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPresentTimingsInfoEXT(const VkPresentTimingsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTimingInfos, object.swapchainCount, settings, "const VkPresentTimingInfoEXT*", "pTimingInfos", "const VkPresentTimingInfoEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentTimingInfoEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderIntegerFunctions2, settings, "VkBool32", "shaderIntegerFunctions2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.value32, settings, "uint32_t", "value32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.value64, settings, "uint64_t", "value64", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.valueFloat, settings, "float", "valueFloat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.valueBool, settings, "VkBool32", "valueBool", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.valueString, settings, "const char*", "valueString", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceValueINTEL(const VkPerformanceValueINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkPerformanceValueTypeINTEL<Format>(object.type, settings, "VkPerformanceValueTypeINTEL", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPerformanceValueDataINTEL<Format>(object.data, settings, "VkPerformanceValueDataINTEL", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkInitializePerformanceApiInfoINTEL(const VkInitializePerformanceApiInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pUserData, settings, "void*", "pUserData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueryPoolPerformanceQueryCreateInfoINTEL(const VkQueryPoolPerformanceQueryCreateInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueryPoolSamplingModeINTEL<Format>(object.performanceCountersSampling, settings, "VkQueryPoolSamplingModeINTEL", "performanceCountersSampling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.marker, settings, "uint64_t", "marker", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceStreamMarkerInfoINTEL(const VkPerformanceStreamMarkerInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.marker, settings, "uint32_t", "marker", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPerformanceOverrideTypeINTEL<Format>(object.type, settings, "VkPerformanceOverrideTypeINTEL", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.enable, settings, "VkBool32", "enable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.parameter, settings, "uint64_t", "parameter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceConfigurationAcquireInfoINTEL(const VkPerformanceConfigurationAcquireInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPerformanceConfigurationTypeINTEL<Format>(object.type, settings, "VkPerformanceConfigurationTypeINTEL", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pciDomain, settings, "uint32_t", "pciDomain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pciBus, settings, "uint32_t", "pciBus", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pciDevice, settings, "uint32_t", "pciDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pciFunction, settings, "uint32_t", "pciFunction", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const VkDisplayNativeHdrSurfaceCapabilitiesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.localDimmingSupport, settings, "VkBool32", "localDimmingSupport", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainDisplayNativeHdrCreateInfoAMD(const VkSwapchainDisplayNativeHdrCreateInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.localDimmingEnable, settings, "VkBool32", "localDimmingEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_FUCHSIA)
template <ApiDumpFormat Format>
void dump_VkImagePipeSurfaceCreateInfoFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImagePipeSurfaceCreateFlagsFUCHSIA<Format>(object.flags, settings, "VkImagePipeSurfaceCreateFlagsFUCHSIA", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, zx_handle_t>(object.imagePipeHandle, settings, "zx_handle_t", "imagePipeHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_METAL_EXT)
template <ApiDumpFormat Format>
void dump_VkMetalSurfaceCreateInfoEXT(const VkMetalSurfaceCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMetalSurfaceCreateFlagsEXT<Format>(object.flags, settings, "VkMetalSurfaceCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const CAMetalLayer*>(object.pLayer, settings, "const CAMetalLayer*", "pLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_METAL_EXT
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentDensityMap, settings, "VkBool32", "fragmentDensityMap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentDensityMapDynamic, settings, "VkBool32", "fragmentDensityMapDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentDensityMapNonSubsampledImages, settings, "VkBool32", "fragmentDensityMapNonSubsampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.minFragmentDensityTexelSize, settings, "VkExtent2D", "minFragmentDensityTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxFragmentDensityTexelSize, settings, "VkExtent2D", "maxFragmentDensityTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentDensityInvocations, settings, "VkBool32", "fragmentDensityInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassFragmentDensityMapCreateInfoEXT(const VkRenderPassFragmentDensityMapCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAttachmentReference<Format>(object.fragmentDensityMapAttachment, settings, "VkAttachmentReference", "fragmentDensityMapAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderingFragmentDensityMapAttachmentInfoEXT(const VkRenderingFragmentDensityMapAttachmentInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageView<Format>(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderCoreProperties2AMD(const VkPhysicalDeviceShaderCoreProperties2AMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderCorePropertiesFlagsAMD<Format>(object.shaderCoreFeatures, settings, "VkShaderCorePropertiesFlagsAMD", "shaderCoreFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.activeComputeUnitCount, settings, "uint32_t", "activeComputeUnitCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const VkPhysicalDeviceCoherentMemoryFeaturesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceCoherentMemory, settings, "VkBool32", "deviceCoherentMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderImageInt64Atomics, settings, "VkBool32", "shaderImageInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseImageInt64Atomics, settings, "VkBool32", "sparseImageInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.heapBudget, std::min(ApiDumpInstance::current().getMemoryHeapCount(), VK_MAX_MEMORY_HEAPS), settings, "VkDeviceSize[VK_MAX_MEMORY_HEAPS]", "heapBudget", "VkDeviceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, VkDeviceSize>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.heapUsage, std::min(ApiDumpInstance::current().getMemoryHeapCount(), VK_MAX_MEMORY_HEAPS), settings, "VkDeviceSize[VK_MAX_MEMORY_HEAPS]", "heapUsage", "VkDeviceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, VkDeviceSize>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const VkPhysicalDeviceMemoryPriorityFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.memoryPriority, settings, "VkBool32", "memoryPriority", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.priority, settings, "float", "priority", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dedicatedAllocationImageAliasing, settings, "VkBool32", "dedicatedAllocationImageAliasing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bufferDeviceAddress, settings, "VkBool32", "bufferDeviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bufferDeviceAddressCaptureReplay, settings, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bufferDeviceAddressMultiDevice, settings, "VkBool32", "bufferDeviceAddressMultiDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkValidationFeaturesEXT(const VkValidationFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.enabledValidationFeatureCount, settings, "uint32_t", "enabledValidationFeatureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pEnabledValidationFeatures, object.enabledValidationFeatureCount, settings, "const VkValidationFeatureEnableEXT*", "pEnabledValidationFeatures", "const VkValidationFeatureEnableEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkValidationFeatureEnableEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.disabledValidationFeatureCount, settings, "uint32_t", "disabledValidationFeatureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDisabledValidationFeatures, object.disabledValidationFeatureCount, settings, "const VkValidationFeatureDisableEXT*", "pDisabledValidationFeatures", "const VkValidationFeatureDisableEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkValidationFeatureDisableEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.MSize, settings, "uint32_t", "MSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.NSize, settings, "uint32_t", "NSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.KSize, settings, "uint32_t", "KSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.AType, settings, "VkComponentTypeNV", "AType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.BType, settings, "VkComponentTypeNV", "BType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.CType, settings, "VkComponentTypeNV", "CType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.DType, settings, "VkComponentTypeNV", "DType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkScopeKHR<Format>(object.scope, settings, "VkScopeNV", "scope", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const VkPhysicalDeviceCooperativeMatrixFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrix, settings, "VkBool32", "cooperativeMatrix", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrixRobustBufferAccess, settings, "VkBool32", "cooperativeMatrixRobustBufferAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const VkPhysicalDeviceCooperativeMatrixPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.cooperativeMatrixSupportedStages, settings, "VkShaderStageFlags", "cooperativeMatrixSupportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const VkPhysicalDeviceCoverageReductionModeFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.coverageReductionMode, settings, "VkBool32", "coverageReductionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCoverageReductionStateCreateInfoNV(const VkPipelineCoverageReductionStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCoverageReductionStateCreateFlagsNV<Format>(object.flags, settings, "VkPipelineCoverageReductionStateCreateFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCoverageReductionModeNV<Format>(object.coverageReductionMode, settings, "VkCoverageReductionModeNV", "coverageReductionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFramebufferMixedSamplesCombinationNV(const VkFramebufferMixedSamplesCombinationNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCoverageReductionModeNV<Format>(object.coverageReductionMode, settings, "VkCoverageReductionModeNV", "coverageReductionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.depthStencilSamples, settings, "VkSampleCountFlags", "depthStencilSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlags<Format>(object.colorSamples, settings, "VkSampleCountFlags", "colorSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShaderSampleInterlock, settings, "VkBool32", "fragmentShaderSampleInterlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShaderPixelInterlock, settings, "VkBool32", "fragmentShaderPixelInterlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShaderShadingRateInterlock, settings, "VkBool32", "fragmentShaderShadingRateInterlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.ycbcrImageArrays, settings, "VkBool32", "ycbcrImageArrays", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceProvokingVertexFeaturesEXT(const VkPhysicalDeviceProvokingVertexFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.provokingVertexLast, settings, "VkBool32", "provokingVertexLast", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.transformFeedbackPreservesProvokingVertex, settings, "VkBool32", "transformFeedbackPreservesProvokingVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceProvokingVertexPropertiesEXT(const VkPhysicalDeviceProvokingVertexPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.provokingVertexModePerPipeline, settings, "VkBool32", "provokingVertexModePerPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.transformFeedbackPreservesTriangleFanProvokingVertex, settings, "VkBool32", "transformFeedbackPreservesTriangleFanProvokingVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkProvokingVertexModeEXT<Format>(object.provokingVertexMode, settings, "VkProvokingVertexModeEXT", "provokingVertexMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
template <ApiDumpFormat Format>
void dump_VkSurfaceFullScreenExclusiveInfoEXT(const VkSurfaceFullScreenExclusiveInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFullScreenExclusiveEXT<Format>(object.fullScreenExclusive, settings, "VkFullScreenExclusiveEXT", "fullScreenExclusive", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const VkSurfaceCapabilitiesFullScreenExclusiveEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fullScreenExclusiveSupported, settings, "VkBool32", "fullScreenExclusiveSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceFullScreenExclusiveWin32InfoEXT(const VkSurfaceFullScreenExclusiveWin32InfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, HMONITOR>(object.hmonitor, settings, "HMONITOR", "hmonitor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR
template <ApiDumpFormat Format>
void dump_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkHeadlessSurfaceCreateFlagsEXT<Format>(object.flags, settings, "VkHeadlessSurfaceCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBufferFloat32Atomics, settings, "VkBool32", "shaderBufferFloat32Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBufferFloat32AtomicAdd, settings, "VkBool32", "shaderBufferFloat32AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBufferFloat64Atomics, settings, "VkBool32", "shaderBufferFloat64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBufferFloat64AtomicAdd, settings, "VkBool32", "shaderBufferFloat64AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSharedFloat32Atomics, settings, "VkBool32", "shaderSharedFloat32Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSharedFloat32AtomicAdd, settings, "VkBool32", "shaderSharedFloat32AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSharedFloat64Atomics, settings, "VkBool32", "shaderSharedFloat64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSharedFloat64AtomicAdd, settings, "VkBool32", "shaderSharedFloat64AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderImageFloat32Atomics, settings, "VkBool32", "shaderImageFloat32Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderImageFloat32AtomicAdd, settings, "VkBool32", "shaderImageFloat32AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseImageFloat32Atomics, settings, "VkBool32", "sparseImageFloat32Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseImageFloat32AtomicAdd, settings, "VkBool32", "sparseImageFloat32AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState, settings, "VkBool32", "extendedDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.memoryMapPlaced, settings, "VkBool32", "memoryMapPlaced", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.memoryMapRangePlaced, settings, "VkBool32", "memoryMapRangePlaced", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.memoryUnmapReserve, settings, "VkBool32", "memoryUnmapReserve", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.minPlacedMemoryMapAlignment, settings, "VkDeviceSize", "minPlacedMemoryMapAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryMapPlacedInfoEXT(const VkMemoryMapPlacedInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pPlacedAddress, settings, "void*", "pPlacedAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBufferFloat16Atomics, settings, "VkBool32", "shaderBufferFloat16Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBufferFloat16AtomicAdd, settings, "VkBool32", "shaderBufferFloat16AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBufferFloat16AtomicMinMax, settings, "VkBool32", "shaderBufferFloat16AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBufferFloat32AtomicMinMax, settings, "VkBool32", "shaderBufferFloat32AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderBufferFloat64AtomicMinMax, settings, "VkBool32", "shaderBufferFloat64AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSharedFloat16Atomics, settings, "VkBool32", "shaderSharedFloat16Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSharedFloat16AtomicAdd, settings, "VkBool32", "shaderSharedFloat16AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSharedFloat16AtomicMinMax, settings, "VkBool32", "shaderSharedFloat16AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSharedFloat32AtomicMinMax, settings, "VkBool32", "shaderSharedFloat32AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSharedFloat64AtomicMinMax, settings, "VkBool32", "shaderSharedFloat64AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderImageFloat32AtomicMinMax, settings, "VkBool32", "shaderImageFloat32AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sparseImageFloat32AtomicMinMax, settings, "VkBool32", "sparseImageFloat32AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGraphicsShaderGroupCount, settings, "uint32_t", "maxGraphicsShaderGroupCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIndirectSequenceCount, settings, "uint32_t", "maxIndirectSequenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIndirectCommandsTokenCount, settings, "uint32_t", "maxIndirectCommandsTokenCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIndirectCommandsStreamCount, settings, "uint32_t", "maxIndirectCommandsStreamCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIndirectCommandsTokenOffset, settings, "uint32_t", "maxIndirectCommandsTokenOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIndirectCommandsStreamStride, settings, "uint32_t", "maxIndirectCommandsStreamStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minSequencesCountBufferOffsetAlignment, settings, "uint32_t", "minSequencesCountBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minSequencesIndexBufferOffsetAlignment, settings, "uint32_t", "minSequencesIndexBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minIndirectCommandsBufferOffsetAlignment, settings, "uint32_t", "minIndirectCommandsBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceGeneratedCommands, settings, "VkBool32", "deviceGeneratedCommands", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGraphicsShaderGroupCreateInfoNV(const VkGraphicsShaderGroupCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stageCount, settings, "uint32_t", "stageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pVertexInputState, settings, "const VkPipelineVertexInputStateCreateInfo*", "pVertexInputState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineVertexInputStateCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pTessellationState, settings, "const VkPipelineTessellationStateCreateInfo*", "pTessellationState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineTessellationStateCreateInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGraphicsPipelineShaderGroupsCreateInfoNV(const VkGraphicsPipelineShaderGroupsCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.groupCount, settings, "uint32_t", "groupCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pGroups, object.groupCount, settings, "const VkGraphicsShaderGroupCreateInfoNV*", "pGroups", "const VkGraphicsShaderGroupCreateInfoNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkGraphicsShaderGroupCreateInfoNV<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pipelineCount, settings, "uint32_t", "pipelineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPipelines, object.pipelineCount, settings, "const VkPipeline*", "pPipelines", "const VkPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipeline<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindShaderGroupIndirectCommandNV(const VkBindShaderGroupIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.groupIndex, settings, "uint32_t", "groupIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindIndexBufferIndirectCommandNV(const VkBindIndexBufferIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndexType<Format>(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindVertexBufferIndirectCommandNV(const VkBindVertexBufferIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSetStateFlagsIndirectCommandNV(const VkSetStateFlagsIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.data, settings, "uint32_t", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsStreamNV(const VkIndirectCommandsStreamNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsLayoutTokenNV(const VkIndirectCommandsLayoutTokenNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectCommandsTokenTypeNV<Format>(object.tokenType, settings, "VkIndirectCommandsTokenTypeNV", "tokenType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stream, settings, "uint32_t", "stream", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vertexBindingUnit, settings, "uint32_t", "vertexBindingUnit", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vertexDynamicStride, settings, "VkBool32", "vertexDynamicStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.pushconstantPipelineLayout, settings, "VkPipelineLayout", "pushconstantPipelineLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.pushconstantShaderStageFlags, settings, "VkShaderStageFlags", "pushconstantShaderStageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pushconstantOffset, settings, "uint32_t", "pushconstantOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pushconstantSize, settings, "uint32_t", "pushconstantSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectStateFlagsNV<Format>(object.indirectStateFlags, settings, "VkIndirectStateFlagsNV", "indirectStateFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.indexTypeCount, settings, "uint32_t", "indexTypeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pIndexTypes, object.indexTypeCount, settings, "const VkIndexType*", "pIndexTypes", "const VkIndexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndexType<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pIndexTypeValues, object.indexTypeCount, settings, "const uint32_t*", "pIndexTypeValues", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsLayoutCreateInfoNV(const VkIndirectCommandsLayoutCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectCommandsLayoutUsageFlagsNV<Format>(object.flags, settings, "VkIndirectCommandsLayoutUsageFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineBindPoint<Format>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tokenCount, settings, "uint32_t", "tokenCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTokens, object.tokenCount, settings, "const VkIndirectCommandsLayoutTokenNV*", "pTokens", "const VkIndirectCommandsLayoutTokenNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsLayoutTokenNV<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.streamCount, settings, "uint32_t", "streamCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStreamStrides, object.streamCount, settings, "const uint32_t*", "pStreamStrides", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeneratedCommandsInfoNV(const VkGeneratedCommandsInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineBindPoint<Format>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectCommandsLayoutNV<Format>(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.streamCount, settings, "uint32_t", "streamCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStreams, object.streamCount, settings, "const VkIndirectCommandsStreamNV*", "pStreams", "const VkIndirectCommandsStreamNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsStreamNV<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sequencesCount, settings, "uint32_t", "sequencesCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.preprocessBuffer, settings, "VkBuffer", "preprocessBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.preprocessOffset, settings, "VkDeviceSize", "preprocessOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.preprocessSize, settings, "VkDeviceSize", "preprocessSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.sequencesCountBuffer, settings, "VkBuffer", "sequencesCountBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.sequencesCountOffset, settings, "VkDeviceSize", "sequencesCountOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.sequencesIndexBuffer, settings, "VkBuffer", "sequencesIndexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.sequencesIndexOffset, settings, "VkDeviceSize", "sequencesIndexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeneratedCommandsMemoryRequirementsInfoNV(const VkGeneratedCommandsMemoryRequirementsInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineBindPoint<Format>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectCommandsLayoutNV<Format>(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSequencesCount, settings, "uint32_t", "maxSequencesCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.inheritedViewportScissor2D, settings, "VkBool32", "inheritedViewportScissor2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferInheritanceViewportScissorInfoNV(const VkCommandBufferInheritanceViewportScissorInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.viewportScissor2D, settings, "VkBool32", "viewportScissor2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.viewportDepthCount, settings, "uint32_t", "viewportDepthCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pViewportDepths, settings, "const VkViewport*", "pViewportDepths", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkViewport<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.texelBufferAlignment, settings, "VkBool32", "texelBufferAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassTransformBeginInfoQCOM(const VkRenderPassTransformBeginInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceTransformFlagBitsKHR<Format>(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceTransformFlagBitsKHR<Format>(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRect2D<Format>(object.renderArea, settings, "VkRect2D", "renderArea", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDepthBiasControlFeaturesEXT(const VkPhysicalDeviceDepthBiasControlFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthBiasControl, settings, "VkBool32", "depthBiasControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.leastRepresentableValueForceUnormRepresentation, settings, "VkBool32", "leastRepresentableValueForceUnormRepresentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.floatRepresentation, settings, "VkBool32", "floatRepresentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthBiasExact, settings, "VkBool32", "depthBiasExact", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDepthBiasInfoEXT(const VkDepthBiasInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.depthBiasConstantFactor, settings, "float", "depthBiasConstantFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.depthBiasClamp, settings, "float", "depthBiasClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.depthBiasSlopeFactor, settings, "float", "depthBiasSlopeFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDepthBiasRepresentationInfoEXT(const VkDepthBiasRepresentationInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDepthBiasRepresentationEXT<Format>(object.depthBiasRepresentation, settings, "VkDepthBiasRepresentationEXT", "depthBiasRepresentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthBiasExact, settings, "VkBool32", "depthBiasExact", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceMemoryReport, settings, "VkBool32", "deviceMemoryReport", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceMemoryReportCallbackDataEXT(const VkDeviceMemoryReportCallbackDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemoryReportFlagsEXT<Format>(object.flags, settings, "VkDeviceMemoryReportFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemoryReportEventTypeEXT<Format>(object.type, settings, "VkDeviceMemoryReportEventTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.memoryObjectId, settings, "uint64_t", "memoryObjectId", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkObjectType<Format>(object.objectType, settings, "VkObjectType", "objectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_uint64_t_as_pointer<Format>(object.objectHandle, settings, "uint64_t", "objectHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.heapIndex, settings, "uint32_t", "heapIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceDeviceMemoryReportCreateInfoEXT(const VkDeviceDeviceMemoryReportCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemoryReportFlagsEXT<Format>(object.flags, settings, "VkDeviceMemoryReportFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_PFN_vkDeviceMemoryReportCallbackEXT<Format>(object.pfnUserCallback, settings, "PFN_vkDeviceMemoryReportCallbackEXT", "pfnUserCallback", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pUserData, settings, "void*", "pUserData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxCustomBorderColorSamplers, settings, "uint32_t", "maxCustomBorderColorSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.customBorderColors, settings, "VkBool32", "customBorderColors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.customBorderColorWithoutFormat, settings, "VkBool32", "customBorderColorWithoutFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.textureCompressionASTC_3D, settings, "VkBool32", "textureCompressionASTC_3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePresentBarrierFeaturesNV(const VkPhysicalDevicePresentBarrierFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentBarrier, settings, "VkBool32", "presentBarrier", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSurfaceCapabilitiesPresentBarrierNV(const VkSurfaceCapabilitiesPresentBarrierNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentBarrierSupported, settings, "VkBool32", "presentBarrierSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainPresentBarrierCreateInfoNV(const VkSwapchainPresentBarrierCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentBarrierEnable, settings, "VkBool32", "presentBarrierEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.diagnosticsConfig, settings, "VkBool32", "diagnosticsConfig", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceDiagnosticsConfigCreateInfoNV(const VkDeviceDiagnosticsConfigCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceDiagnosticsConfigFlagsNV<Format>(object.flags, settings, "VkDeviceDiagnosticsConfigFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerfHintInfoQCOM(const VkPerfHintInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPerfHintTypeQCOM<Format>(object.type, settings, "VkPerfHintTypeQCOM", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.scale, settings, "uint32_t", "scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceQueuePerfHintFeaturesQCOM(const VkPhysicalDeviceQueuePerfHintFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.queuePerfHint, settings, "VkBool32", "queuePerfHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceQueuePerfHintPropertiesQCOM(const VkPhysicalDeviceQueuePerfHintPropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueueFlags<Format>(object.supportedQueues, settings, "VkQueueFlags", "supportedQueues", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageProcessing3FeaturesQCOM(const VkPhysicalDeviceImageProcessing3FeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imageGatherLinear, settings, "VkBool32", "imageGatherLinear", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imageGatherExtendedModes, settings, "VkBool32", "imageGatherExtendedModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.blockMatchExtendedClampToEdge, settings, "VkBool32", "blockMatchExtendedClampToEdge", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM(const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderMultipleWaitQueues, settings, "VkBool32", "shaderMultipleWaitQueues", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM(const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxShaderWaitQueues, settings, "uint32_t", "maxShaderWaitQueues", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT(const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSplitBarrier, settings, "VkBool32", "shaderSplitBarrier", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT(const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.splitBarrierReservedSharedMemory, settings, "uint32_t", "splitBarrierReservedSharedMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
template <ApiDumpFormat Format>
void dump_VkCudaModuleCreateInfoNV(const VkCudaModuleCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pData, settings, "const void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCudaFunctionCreateInfoNV(const VkCudaFunctionCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCudaModuleNV<Format>(object.module, settings, "VkCudaModuleNV", "module", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCudaLaunchInfoNV(const VkCudaLaunchInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCudaFunctionNV<Format>(object.function, settings, "VkCudaFunctionNV", "function", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gridDimX, settings, "uint32_t", "gridDimX", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gridDimY, settings, "uint32_t", "gridDimY", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.gridDimZ, settings, "uint32_t", "gridDimZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.blockDimX, settings, "uint32_t", "blockDimX", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.blockDimY, settings, "uint32_t", "blockDimY", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.blockDimZ, settings, "uint32_t", "blockDimZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sharedMemBytes, settings, "uint32_t", "sharedMemBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.paramCount, settings, "size_t", "paramCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pParams, object.paramCount, settings, "const void* const *", "pParams", "const void*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const void*>);
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.extraCount, settings, "size_t", "extraCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pExtras, object.extraCount, settings, "const void* const *", "pExtras", "const void*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const void*>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(const VkPhysicalDeviceCudaKernelLaunchFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cudaKernelLaunchFeatures, settings, "VkBool32", "cudaKernelLaunchFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(const VkPhysicalDeviceCudaKernelLaunchPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.computeCapabilityMinor, settings, "uint32_t", "computeCapabilityMinor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.computeCapabilityMajor, settings, "uint32_t", "computeCapabilityMajor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_ENABLE_BETA_EXTENSIONS
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTileShadingFeaturesQCOM(const VkPhysicalDeviceTileShadingFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShading, settings, "VkBool32", "tileShading", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingFragmentStage, settings, "VkBool32", "tileShadingFragmentStage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingColorAttachments, settings, "VkBool32", "tileShadingColorAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingDepthAttachments, settings, "VkBool32", "tileShadingDepthAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingStencilAttachments, settings, "VkBool32", "tileShadingStencilAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingInputAttachments, settings, "VkBool32", "tileShadingInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingSampledAttachments, settings, "VkBool32", "tileShadingSampledAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingPerTileDraw, settings, "VkBool32", "tileShadingPerTileDraw", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingPerTileDispatch, settings, "VkBool32", "tileShadingPerTileDispatch", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingDispatchTile, settings, "VkBool32", "tileShadingDispatchTile", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingApron, settings, "VkBool32", "tileShadingApron", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingAnisotropicApron, settings, "VkBool32", "tileShadingAnisotropicApron", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingAtomicOps, settings, "VkBool32", "tileShadingAtomicOps", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileShadingImageProcessing, settings, "VkBool32", "tileShadingImageProcessing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTileShadingPropertiesQCOM(const VkPhysicalDeviceTileShadingPropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxApronSize, settings, "uint32_t", "maxApronSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.preferNonCoherent, settings, "VkBool32", "preferNonCoherent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.tileGranularity, settings, "VkExtent2D", "tileGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxTileShadingRate, settings, "VkExtent2D", "maxTileShadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassTileShadingCreateInfoQCOM(const VkRenderPassTileShadingCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTileShadingRenderPassFlagsQCOM<Format>(object.flags, settings, "VkTileShadingRenderPassFlagsQCOM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.tileApronSize, settings, "VkExtent2D", "tileApronSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerTileBeginInfoQCOM(const VkPerTileBeginInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerTileEndInfoQCOM(const VkPerTileEndInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDispatchTileInfoQCOM(const VkDispatchTileInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pQueriedLowLatencyData, settings, "void*", "pQueriedLowLatencyData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_METAL_EXT)
template <ApiDumpFormat Format>
void dump_VkExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExportMetalObjectTypeFlagBitsEXT<Format>(object.exportObjectType, settings, "VkExportMetalObjectTypeFlagBitsEXT", "exportObjectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportMetalObjectsInfoEXT(const VkExportMetalObjectsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportMetalDeviceInfoEXT(const VkExportMetalDeviceInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, MTLDevice_id>(object.mtlDevice, settings, "MTLDevice_id", "mtlDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportMetalCommandQueueInfoEXT(const VkExportMetalCommandQueueInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueue<Format>(object.queue, settings, "VkQueue", "queue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, MTLCommandQueue_id>(object.mtlCommandQueue, settings, "MTLCommandQueue_id", "mtlCommandQueue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportMetalBufferInfoEXT(const VkExportMetalBufferInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, MTLBuffer_id>(object.mtlBuffer, settings, "MTLBuffer_id", "mtlBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImportMetalBufferInfoEXT(const VkImportMetalBufferInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, MTLBuffer_id>(object.mtlBuffer, settings, "MTLBuffer_id", "mtlBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportMetalTextureInfoEXT(const VkExportMetalTextureInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageView<Format>(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferView<Format>(object.bufferView, settings, "VkBufferView", "bufferView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageAspectFlagBits<Format>(object.plane, settings, "VkImageAspectFlagBits", "plane", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, MTLTexture_id>(object.mtlTexture, settings, "MTLTexture_id", "mtlTexture", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImportMetalTextureInfoEXT(const VkImportMetalTextureInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageAspectFlagBits<Format>(object.plane, settings, "VkImageAspectFlagBits", "plane", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, MTLTexture_id>(object.mtlTexture, settings, "MTLTexture_id", "mtlTexture", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportMetalIOSurfaceInfoEXT(const VkExportMetalIOSurfaceInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, IOSurfaceRef>(object.ioSurface, settings, "IOSurfaceRef", "ioSurface", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImportMetalIOSurfaceInfoEXT(const VkImportMetalIOSurfaceInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, IOSurfaceRef>(object.ioSurface, settings, "IOSurfaceRef", "ioSurface", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExportMetalSharedEventInfoEXT(const VkExportMetalSharedEventInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphore<Format>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkEvent<Format>(object.event, settings, "VkEvent", "event", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, MTLSharedEvent_id>(object.mtlSharedEvent, settings, "MTLSharedEvent_id", "mtlSharedEvent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImportMetalSharedEventInfoEXT(const VkImportMetalSharedEventInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, MTLSharedEvent_id>(object.mtlSharedEvent, settings, "MTLSharedEvent_id", "mtlSharedEvent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_METAL_EXT
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorBufferPropertiesEXT(const VkPhysicalDeviceDescriptorBufferPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.combinedImageSamplerDescriptorSingleArray, settings, "VkBool32", "combinedImageSamplerDescriptorSingleArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bufferlessPushDescriptors, settings, "VkBool32", "bufferlessPushDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.allowSamplerImageViewPostSubmitCreation, settings, "VkBool32", "allowSamplerImageViewPostSubmitCreation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.descriptorBufferOffsetAlignment, settings, "VkDeviceSize", "descriptorBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorBufferBindings, settings, "uint32_t", "maxDescriptorBufferBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxResourceDescriptorBufferBindings, settings, "uint32_t", "maxResourceDescriptorBufferBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSamplerDescriptorBufferBindings, settings, "uint32_t", "maxSamplerDescriptorBufferBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxEmbeddedImmutableSamplerBindings, settings, "uint32_t", "maxEmbeddedImmutableSamplerBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxEmbeddedImmutableSamplers, settings, "uint32_t", "maxEmbeddedImmutableSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.bufferCaptureReplayDescriptorDataSize, settings, "size_t", "bufferCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.imageCaptureReplayDescriptorDataSize, settings, "size_t", "imageCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.imageViewCaptureReplayDescriptorDataSize, settings, "size_t", "imageViewCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.samplerCaptureReplayDescriptorDataSize, settings, "size_t", "samplerCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.accelerationStructureCaptureReplayDescriptorDataSize, settings, "size_t", "accelerationStructureCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.samplerDescriptorSize, settings, "size_t", "samplerDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.combinedImageSamplerDescriptorSize, settings, "size_t", "combinedImageSamplerDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.sampledImageDescriptorSize, settings, "size_t", "sampledImageDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.storageImageDescriptorSize, settings, "size_t", "storageImageDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.uniformTexelBufferDescriptorSize, settings, "size_t", "uniformTexelBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.robustUniformTexelBufferDescriptorSize, settings, "size_t", "robustUniformTexelBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.storageTexelBufferDescriptorSize, settings, "size_t", "storageTexelBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.robustStorageTexelBufferDescriptorSize, settings, "size_t", "robustStorageTexelBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.uniformBufferDescriptorSize, settings, "size_t", "uniformBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.robustUniformBufferDescriptorSize, settings, "size_t", "robustUniformBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.storageBufferDescriptorSize, settings, "size_t", "storageBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.robustStorageBufferDescriptorSize, settings, "size_t", "robustStorageBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.inputAttachmentDescriptorSize, settings, "size_t", "inputAttachmentDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.accelerationStructureDescriptorSize, settings, "size_t", "accelerationStructureDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxSamplerDescriptorBufferRange, settings, "VkDeviceSize", "maxSamplerDescriptorBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxResourceDescriptorBufferRange, settings, "VkDeviceSize", "maxResourceDescriptorBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.samplerDescriptorBufferAddressSpaceSize, settings, "VkDeviceSize", "samplerDescriptorBufferAddressSpaceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.resourceDescriptorBufferAddressSpaceSize, settings, "VkDeviceSize", "resourceDescriptorBufferAddressSpaceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.descriptorBufferAddressSpaceSize, settings, "VkDeviceSize", "descriptorBufferAddressSpaceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorBufferFeaturesEXT(const VkPhysicalDeviceDescriptorBufferFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBuffer, settings, "VkBool32", "descriptorBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBufferCaptureReplay, settings, "VkBool32", "descriptorBufferCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBufferImageLayoutIgnored, settings, "VkBool32", "descriptorBufferImageLayoutIgnored", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBufferPushDescriptors, settings, "VkBool32", "descriptorBufferPushDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.address, settings, "VkDeviceAddress", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.range, settings, "VkDeviceSize", "range", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorBufferBindingInfoEXT(const VkDescriptorBufferBindingInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.address, settings, "VkDeviceAddress", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferUsageFlags<Format>(object.usage, settings, "VkBufferUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorDataEXT(const VkDescriptorDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLER) {
        dump_pointer<Format>(object.pSampler, settings, "const VkSampler*", "pSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSampler<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
        dump_pointer<Format>(object.pCombinedImageSampler, settings, "const VkDescriptorImageInfo*", "pCombinedImageSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) {
        dump_pointer<Format>(object.pInputAttachmentImage, settings, "const VkDescriptorImageInfo*", "pInputAttachmentImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) {
        dump_pointer<Format>(object.pSampledImage, settings, "const VkDescriptorImageInfo*", "pSampledImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
        dump_pointer<Format>(object.pStorageImage, settings, "const VkDescriptorImageInfo*", "pStorageImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) {
        dump_pointer<Format>(object.pUniformTexelBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pUniformTexelBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) {
        dump_pointer<Format>(object.pStorageTexelBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pStorageTexelBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) {
        dump_pointer<Format>(object.pUniformBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pUniformBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
        dump_pointer<Format>(object.pStorageBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pStorageBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR) {
        dump_type_hex<Format, VkDeviceAddress>(object.accelerationStructure, settings, "VkDeviceAddress", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    ApiDumpInstance::current().setDescriptorType(object.type);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorType<Format>(object.type, settings, "VkDescriptorType", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorDataEXT<Format>(object.data, settings, "VkDescriptorDataEXT", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferCaptureDescriptorDataInfoEXT(const VkBufferCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageCaptureDescriptorDataInfoEXT(const VkImageCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImage<Format>(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageViewCaptureDescriptorDataInfoEXT(const VkImageViewCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageView<Format>(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerCaptureDescriptorDataInfoEXT(const VkSamplerCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampler<Format>(object.sampler, settings, "VkSampler", "sampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkOpaqueCaptureDescriptorDataCreateInfoEXT(const VkOpaqueCaptureDescriptorDataCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.opaqueCaptureDescriptorData, settings, "const void*", "opaqueCaptureDescriptorData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureCaptureDescriptorDataInfoEXT(const VkAccelerationStructureCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureKHR<Format>(object.accelerationStructure, settings, "VkAccelerationStructureKHR", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureNV<Format>(object.accelerationStructureNV, settings, "VkAccelerationStructureNV", "accelerationStructureNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.combinedImageSamplerDensityMapDescriptorSize, settings, "size_t", "combinedImageSamplerDensityMapDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.graphicsPipelineLibrary, settings, "VkBool32", "graphicsPipelineLibrary", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.graphicsPipelineLibraryFastLinking, settings, "VkBool32", "graphicsPipelineLibraryFastLinking", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.graphicsPipelineLibraryIndependentInterpolationDecoration, settings, "VkBool32", "graphicsPipelineLibraryIndependentInterpolationDecoration", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGraphicsPipelineLibraryCreateInfoEXT(const VkGraphicsPipelineLibraryCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGraphicsPipelineLibraryFlagsEXT<Format>(object.flags, settings, "VkGraphicsPipelineLibraryFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderEarlyAndLateFragmentTests, settings, "VkBool32", "shaderEarlyAndLateFragmentTests", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentShadingRateEnums, settings, "VkBool32", "fragmentShadingRateEnums", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.supersampleFragmentShadingRates, settings, "VkBool32", "supersampleFragmentShadingRates", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.noInvocationFragmentShadingRates, settings, "VkBool32", "noInvocationFragmentShadingRates", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.maxFragmentShadingRateInvocationCount, settings, "VkSampleCountFlagBits", "maxFragmentShadingRateInvocationCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFragmentShadingRateTypeNV<Format>(object.shadingRateType, settings, "VkFragmentShadingRateTypeNV", "shadingRateType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFragmentShadingRateNV<Format>(object.shadingRate, settings, "VkFragmentShadingRateNV", "shadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.combinerOps, 2, settings, "VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "VkFragmentShadingRateCombinerOpKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFragmentShadingRateCombinerOpKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.hostAddress, settings, "const void*", "hostAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureGeometryMotionTrianglesDataNV(const VkAccelerationStructureGeometryMotionTrianglesDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureMotionInfoNV(const VkAccelerationStructureMotionInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxInstances, settings, "uint32_t", "maxInstances", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureMotionInfoFlagsNV<Format>(object.flags, settings, "VkAccelerationStructureMotionInfoFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureMatrixMotionInstanceNV(const VkAccelerationStructureMatrixMotionInstanceNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkTransformMatrixKHR<Format>(object.transformT0, settings, "VkTransformMatrixKHR", "transformT0", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTransformMatrixKHR<Format>(object.transformT1, settings, "VkTransformMatrixKHR", "transformT1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceCustomIndex, settings, "uint32_t:24", "instanceCustomIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.mask, settings, "uint32_t:8", "mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceShaderBindingTableRecordOffset, settings, "uint32_t:24", "instanceShaderBindingTableRecordOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGeometryInstanceFlagsKHR<Format>(object.flags, settings, "VkGeometryInstanceFlagsKHR:8", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.accelerationStructureReference, settings, "uint64_t", "accelerationStructureReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSRTDataNV(const VkSRTDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, float>(object.sx, settings, "float", "sx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.a, settings, "float", "a", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.b, settings, "float", "b", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.pvx, settings, "float", "pvx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.sy, settings, "float", "sy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.c, settings, "float", "c", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.pvy, settings, "float", "pvy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.sz, settings, "float", "sz", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.pvz, settings, "float", "pvz", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.qx, settings, "float", "qx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.qy, settings, "float", "qy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.qz, settings, "float", "qz", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.qw, settings, "float", "qw", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.tx, settings, "float", "tx", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.ty, settings, "float", "ty", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.tz, settings, "float", "tz", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureSRTMotionInstanceNV(const VkAccelerationStructureSRTMotionInstanceNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkSRTDataNV<Format>(object.transformT0, settings, "VkSRTDataNV", "transformT0", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSRTDataNV<Format>(object.transformT1, settings, "VkSRTDataNV", "transformT1", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceCustomIndex, settings, "uint32_t:24", "instanceCustomIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.mask, settings, "uint32_t:8", "mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceShaderBindingTableRecordOffset, settings, "uint32_t:24", "instanceShaderBindingTableRecordOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGeometryInstanceFlagsKHR<Format>(object.flags, settings, "VkGeometryInstanceFlagsKHR:8", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.accelerationStructureReference, settings, "uint64_t", "accelerationStructureReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureMotionInstanceDataNV(const VkAccelerationStructureMotionInstanceDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    dump_VkAccelerationStructureInstanceKHR<Format>(object.staticInstance, settings, "VkAccelerationStructureInstanceKHR", "staticInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureMatrixMotionInstanceNV<Format>(object.matrixMotionInstance, settings, "VkAccelerationStructureMatrixMotionInstanceNV", "matrixMotionInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureSRTMotionInstanceNV<Format>(object.srtMotionInstance, settings, "VkAccelerationStructureSRTMotionInstanceNV", "srtMotionInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureMotionInstanceNV(const VkAccelerationStructureMotionInstanceNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkAccelerationStructureMotionInstanceTypeNV<Format>(object.type, settings, "VkAccelerationStructureMotionInstanceTypeNV", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureMotionInstanceFlagsNV<Format>(object.flags, settings, "VkAccelerationStructureMotionInstanceFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureMotionInstanceDataNV<Format>(object.data, settings, "VkAccelerationStructureMotionInstanceDataNV", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingMotionBlur, settings, "VkBool32", "rayTracingMotionBlur", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingMotionBlurPipelineTraceRaysIndirect, settings, "VkBool32", "rayTracingMotionBlurPipelineTraceRaysIndirect", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.ycbcr2plane444Formats, settings, "VkBool32", "ycbcr2plane444Formats", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentDensityMapDeferred, settings, "VkBool32", "fragmentDensityMapDeferred", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.subsampledLoads, settings, "VkBool32", "subsampledLoads", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.subsampledCoarseReconstructionEarlyAccess, settings, "VkBool32", "subsampledCoarseReconstructionEarlyAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSubsampledArrayLayers, settings, "uint32_t", "maxSubsampledArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetSubsampledSamplers, settings, "uint32_t", "maxDescriptorSetSubsampledSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceTransformFlagBitsKHR<Format>(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageCompressionControlFeaturesEXT(const VkPhysicalDeviceImageCompressionControlFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imageCompressionControl, settings, "VkBool32", "imageCompressionControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageCompressionControlEXT(const VkImageCompressionControlEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageCompressionFlagsEXT<Format>(object.flags, settings, "VkImageCompressionFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.compressionControlPlaneCount, settings, "uint32_t", "compressionControlPlaneCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pFixedRateFlags, object.compressionControlPlaneCount, settings, "VkImageCompressionFixedRateFlagsEXT*", "pFixedRateFlags", "VkImageCompressionFixedRateFlagsEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCompressionFixedRateFlagsEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageCompressionPropertiesEXT(const VkImageCompressionPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageCompressionFlagsEXT<Format>(object.imageCompressionFlags, settings, "VkImageCompressionFlagsEXT", "imageCompressionFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageCompressionFixedRateFlagsEXT<Format>(object.imageCompressionFixedRateFlags, settings, "VkImageCompressionFixedRateFlagsEXT", "imageCompressionFixedRateFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.attachmentFeedbackLoopLayout, settings, "VkBool32", "attachmentFeedbackLoopLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.formatA4R4G4B4, settings, "VkBool32", "formatA4R4G4B4", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.formatA4B4G4R4, settings, "VkBool32", "formatA4B4G4R4", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFaultFeaturesEXT(const VkPhysicalDeviceFaultFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceFault, settings, "VkBool32", "deviceFault", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceFaultVendorBinary, settings, "VkBool32", "deviceFaultVendorBinary", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceFaultCountsEXT(const VkDeviceFaultCountsEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.addressInfoCount, settings, "uint32_t", "addressInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vendorInfoCount, settings, "uint32_t", "vendorInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.vendorBinarySize, settings, "VkDeviceSize", "vendorBinarySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceFaultInfoEXT(const VkDeviceFaultInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pAddressInfos, settings, "VkDeviceFaultAddressInfoKHR*", "pAddressInfos", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceFaultAddressInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pVendorInfos, settings, "VkDeviceFaultVendorInfoKHR*", "pVendorInfos", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceFaultVendorInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pVendorBinaryData, settings, "void*", "pVendorBinaryData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rasterizationOrderColorAttachmentAccess, settings, "VkBool32", "rasterizationOrderColorAttachmentAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rasterizationOrderDepthAttachmentAccess, settings, "VkBool32", "rasterizationOrderDepthAttachmentAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rasterizationOrderStencilAttachmentAccess, settings, "VkBool32", "rasterizationOrderStencilAttachmentAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.formatRgba10x6WithoutYCbCrSampler, settings, "VkBool32", "formatRgba10x6WithoutYCbCrSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
template <ApiDumpFormat Format>
void dump_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDirectFBSurfaceCreateFlagsEXT<Format>(object.flags, settings, "VkDirectFBSurfaceCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, IDirectFB*>(object.dfb, settings, "IDirectFB*", "dfb", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, IDirectFBSurface*>(object.surface, settings, "IDirectFBSurface*", "surface", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_DIRECTFB_EXT
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.mutableDescriptorType, settings, "VkBool32", "mutableDescriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.descriptorTypeCount, settings, "uint32_t", "descriptorTypeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDescriptorTypes, object.descriptorTypeCount, settings, "const VkDescriptorType*", "pDescriptorTypes", "const VkDescriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorType<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMutableDescriptorTypeCreateInfoEXT(const VkMutableDescriptorTypeCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.mutableDescriptorTypeListCount, settings, "uint32_t", "mutableDescriptorTypeListCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pMutableDescriptorTypeLists, object.mutableDescriptorTypeListCount, settings, "const VkMutableDescriptorTypeListEXT*", "pMutableDescriptorTypeLists", "const VkMutableDescriptorTypeListEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMutableDescriptorTypeListEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vertexInputDynamicState, settings, "VkBool32", "vertexInputDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVertexInputRate<Format>(object.inputRate, settings, "VkVertexInputRate", "inputRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.divisor, settings, "uint32_t", "divisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.location, settings, "uint32_t", "location", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDrmPropertiesEXT(const VkPhysicalDeviceDrmPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hasPrimary, settings, "VkBool32", "hasPrimary", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hasRender, settings, "VkBool32", "hasRender", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int64_t>(object.primaryMajor, settings, "int64_t", "primaryMajor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int64_t>(object.primaryMinor, settings, "int64_t", "primaryMinor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int64_t>(object.renderMajor, settings, "int64_t", "renderMajor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int64_t>(object.renderMinor, settings, "int64_t", "renderMinor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceAddressBindingReportFeaturesEXT(const VkPhysicalDeviceAddressBindingReportFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.reportAddressBinding, settings, "VkBool32", "reportAddressBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceAddressBindingCallbackDataEXT(const VkDeviceAddressBindingCallbackDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressBindingFlagsEXT<Format>(object.flags, settings, "VkDeviceAddressBindingFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.baseAddress, settings, "VkDeviceAddress", "baseAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceAddressBindingTypeEXT<Format>(object.bindingType, settings, "VkDeviceAddressBindingTypeEXT", "bindingType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDepthClipControlFeaturesEXT(const VkPhysicalDeviceDepthClipControlFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthClipControl, settings, "VkBool32", "depthClipControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineViewportDepthClipControlCreateInfoEXT(const VkPipelineViewportDepthClipControlCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.negativeOneToOne, settings, "VkBool32", "negativeOneToOne", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primitiveTopologyListRestart, settings, "VkBool32", "primitiveTopologyListRestart", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primitiveTopologyPatchListRestart, settings, "VkBool32", "primitiveTopologyPatchListRestart", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_FUCHSIA)
template <ApiDumpFormat Format>
void dump_VkImportMemoryZirconHandleInfoFUCHSIA(const VkImportMemoryZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, zx_handle_t>(object.handle, settings, "zx_handle_t", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryZirconHandlePropertiesFUCHSIA(const VkMemoryZirconHandlePropertiesFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryGetZirconHandleInfoFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImportSemaphoreZirconHandleInfoFUCHSIA(const VkImportSemaphoreZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphore<Format>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphoreImportFlags<Format>(object.flags, settings, "VkSemaphoreImportFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, zx_handle_t>(object.zirconHandle, settings, "zx_handle_t", "zirconHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSemaphoreGetZirconHandleInfoFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphore<Format>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferCollectionCreateInfoFUCHSIA(const VkBufferCollectionCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, zx_handle_t>(object.collectionToken, settings, "zx_handle_t", "collectionToken", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImportMemoryBufferCollectionFUCHSIA(const VkImportMemoryBufferCollectionFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferCollectionFUCHSIA<Format>(object.collection, settings, "VkBufferCollectionFUCHSIA", "collection", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferCollectionImageCreateInfoFUCHSIA(const VkBufferCollectionImageCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferCollectionFUCHSIA<Format>(object.collection, settings, "VkBufferCollectionFUCHSIA", "collection", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferCollectionConstraintsInfoFUCHSIA(const VkBufferCollectionConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minBufferCount, settings, "uint32_t", "minBufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxBufferCount, settings, "uint32_t", "maxBufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minBufferCountForCamping, settings, "uint32_t", "minBufferCountForCamping", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minBufferCountForDedicatedSlack, settings, "uint32_t", "minBufferCountForDedicatedSlack", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minBufferCountForSharedSlack, settings, "uint32_t", "minBufferCountForSharedSlack", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferConstraintsInfoFUCHSIA(const VkBufferConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferCreateInfo<Format>(object.createInfo, settings, "VkBufferCreateInfo", "createInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags<Format>(object.requiredFormatFeatures, settings, "VkFormatFeatureFlags", "requiredFormatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferCollectionConstraintsInfoFUCHSIA<Format>(object.bufferCollectionConstraints, settings, "VkBufferCollectionConstraintsInfoFUCHSIA", "bufferCollectionConstraints", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferCollectionBufferCreateInfoFUCHSIA(const VkBufferCollectionBufferCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferCollectionFUCHSIA<Format>(object.collection, settings, "VkBufferCollectionFUCHSIA", "collection", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSysmemColorSpaceFUCHSIA(const VkSysmemColorSpaceFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorSpace, settings, "uint32_t", "colorSpace", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBufferCollectionPropertiesFUCHSIA(const VkBufferCollectionPropertiesFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bufferCount, settings, "uint32_t", "bufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.createInfoIndex, settings, "uint32_t", "createInfoIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.sysmemPixelFormat, settings, "uint64_t", "sysmemPixelFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags<Format>(object.formatFeatures, settings, "VkFormatFeatureFlags", "formatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSysmemColorSpaceFUCHSIA<Format>(object.sysmemColorSpaceIndex, settings, "VkSysmemColorSpaceFUCHSIA", "sysmemColorSpaceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentMapping<Format>(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrModelConversion<Format>(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrRange<Format>(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageFormatConstraintsInfoFUCHSIA(const VkImageFormatConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageCreateInfo<Format>(object.imageCreateInfo, settings, "VkImageCreateInfo", "imageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags<Format>(object.requiredFormatFeatures, settings, "VkFormatFeatureFlags", "requiredFormatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageFormatConstraintsFlagsFUCHSIA<Format>(object.flags, settings, "VkImageFormatConstraintsFlagsFUCHSIA", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.sysmemPixelFormat, settings, "uint64_t", "sysmemPixelFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorSpaceCount, settings, "uint32_t", "colorSpaceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pColorSpaces, object.colorSpaceCount, settings, "const VkSysmemColorSpaceFUCHSIA*", "pColorSpaces", "const VkSysmemColorSpaceFUCHSIA", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSysmemColorSpaceFUCHSIA<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageConstraintsInfoFUCHSIA(const VkImageConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.formatConstraintsCount, settings, "uint32_t", "formatConstraintsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pFormatConstraints, object.formatConstraintsCount, settings, "const VkImageFormatConstraintsInfoFUCHSIA*", "pFormatConstraints", "const VkImageFormatConstraintsInfoFUCHSIA", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageFormatConstraintsInfoFUCHSIA<Format>);
    dump_separate_members<Format>(settings);
    dump_VkBufferCollectionConstraintsInfoFUCHSIA<Format>(object.bufferCollectionConstraints, settings, "VkBufferCollectionConstraintsInfoFUCHSIA", "bufferCollectionConstraints", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageConstraintsInfoFlagsFUCHSIA<Format>(object.flags, settings, "VkImageConstraintsInfoFlagsFUCHSIA", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_FUCHSIA
template <ApiDumpFormat Format>
void dump_VkSubpassShadingPipelineCreateInfoHUAWEI(const VkSubpassShadingPipelineCreateInfoHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRenderPass<Format>(object.renderPass, settings, "VkRenderPass", "renderPass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subpass, settings, "uint32_t", "subpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.subpassShading, settings, "VkBool32", "subpassShading", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSubpassShadingWorkgroupSizeAspectRatio, settings, "uint32_t", "maxSubpassShadingWorkgroupSizeAspectRatio", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.invocationMask, settings, "VkBool32", "invocationMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryGetRemoteAddressInfoNV(const VkMemoryGetRemoteAddressInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.externalMemoryRDMA, settings, "VkBool32", "externalMemoryRDMA", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.pipelineIdentifier, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "pipelineIdentifier", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePipelinePropertiesFeaturesEXT(const VkPhysicalDevicePipelinePropertiesFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelinePropertiesIdentifier, settings, "VkBool32", "pipelinePropertiesIdentifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFrameBoundaryFeaturesEXT(const VkPhysicalDeviceFrameBoundaryFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.frameBoundary, settings, "VkBool32", "frameBoundary", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFrameBoundaryEXT(const VkFrameBoundaryEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFrameBoundaryFlagsEXT<Format>(object.flags, settings, "VkFrameBoundaryFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.frameID, settings, "uint64_t", "frameID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.imageCount, settings, "uint32_t", "imageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pImages, object.imageCount, settings, "const VkImage*", "pImages", "const VkImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImage<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bufferCount, settings, "uint32_t", "bufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pBuffers, object.bufferCount, settings, "const VkBuffer*", "pBuffers", "const VkBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBuffer<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.tagName, settings, "uint64_t", "tagName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.tagSize, settings, "size_t", "tagSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pTag, settings, "const void*", "pTag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multisampledRenderToSingleSampled, settings, "VkBool32", "multisampledRenderToSingleSampled", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSubpassResolvePerformanceQueryEXT(const VkSubpassResolvePerformanceQueryEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.optimal, settings, "VkBool32", "optimal", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMultisampledRenderToSingleSampledInfoEXT(const VkMultisampledRenderToSingleSampledInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multisampledRenderToSingleSampledEnable, settings, "VkBool32", "multisampledRenderToSingleSampledEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSampleCountFlagBits<Format>(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState2, settings, "VkBool32", "extendedDynamicState2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState2LogicOp, settings, "VkBool32", "extendedDynamicState2LogicOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState2PatchControlPoints, settings, "VkBool32", "extendedDynamicState2PatchControlPoints", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
template <ApiDumpFormat Format>
void dump_VkScreenSurfaceCreateInfoQNX(const VkScreenSurfaceCreateInfoQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkScreenSurfaceCreateFlagsQNX<Format>(object.flags, settings, "VkScreenSurfaceCreateFlagsQNX", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, struct _screen_context*>(object.context, settings, "struct _screen_context*", "context", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, struct _screen_window*>(object.window, settings, "struct _screen_window*", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_SCREEN_QNX
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.colorWriteEnable, settings, "VkBool32", "colorWriteEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pColorWriteEnables, object.attachmentCount, settings, "const VkBool32*", "pColorWriteEnables", "const VkBool32", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const VkBool32>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primitivesGeneratedQuery, settings, "VkBool32", "primitivesGeneratedQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primitivesGeneratedQueryWithRasterizerDiscard, settings, "VkBool32", "primitivesGeneratedQueryWithRasterizerDiscard", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primitivesGeneratedQueryWithNonZeroStreams, settings, "VkBool32", "primitivesGeneratedQueryWithNonZeroStreams", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.videoEncodeRgbConversion, settings, "VkBool32", "videoEncodeRgbConversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeRgbConversionCapabilitiesVALVE(const VkVideoEncodeRgbConversionCapabilitiesVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRgbModelConversionFlagsVALVE<Format>(object.rgbModels, settings, "VkVideoEncodeRgbModelConversionFlagsVALVE", "rgbModels", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRgbRangeCompressionFlagsVALVE<Format>(object.rgbRanges, settings, "VkVideoEncodeRgbRangeCompressionFlagsVALVE", "rgbRanges", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRgbChromaOffsetFlagsVALVE<Format>(object.xChromaOffsets, settings, "VkVideoEncodeRgbChromaOffsetFlagsVALVE", "xChromaOffsets", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRgbChromaOffsetFlagsVALVE<Format>(object.yChromaOffsets, settings, "VkVideoEncodeRgbChromaOffsetFlagsVALVE", "yChromaOffsets", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeProfileRgbConversionInfoVALVE(const VkVideoEncodeProfileRgbConversionInfoVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.performEncodeRgbConversion, settings, "VkBool32", "performEncodeRgbConversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(const VkVideoEncodeSessionRgbConversionCreateInfoVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRgbModelConversionFlagBitsVALVE<Format>(object.rgbModel, settings, "VkVideoEncodeRgbModelConversionFlagBitsVALVE", "rgbModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE<Format>(object.rgbRange, settings, "VkVideoEncodeRgbRangeCompressionFlagBitsVALVE", "rgbRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE<Format>(object.xChromaOffset, settings, "VkVideoEncodeRgbChromaOffsetFlagBitsVALVE", "xChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE<Format>(object.yChromaOffset, settings, "VkVideoEncodeRgbChromaOffsetFlagBitsVALVE", "yChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageViewMinLodFeaturesEXT(const VkPhysicalDeviceImageViewMinLodFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.minLod, settings, "VkBool32", "minLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageViewMinLodCreateInfoEXT(const VkImageViewMinLodCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.minLod, settings, "float", "minLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMultiDrawFeaturesEXT(const VkPhysicalDeviceMultiDrawFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiDraw, settings, "VkBool32", "multiDraw", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMultiDrawPropertiesEXT(const VkPhysicalDeviceMultiDrawPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMultiDrawCount, settings, "uint32_t", "maxMultiDrawCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMultiDrawInfoEXT(const VkMultiDrawInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.firstVertex, settings, "uint32_t", "firstVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vertexCount, settings, "uint32_t", "vertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMultiDrawIndexedInfoEXT(const VkMultiDrawIndexedInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.firstIndex, settings, "uint32_t", "firstIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.indexCount, settings, "uint32_t", "indexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.vertexOffset, settings, "int32_t", "vertexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.image2DViewOf3D, settings, "VkBool32", "image2DViewOf3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.sampler2DViewOf3D, settings, "VkBool32", "sampler2DViewOf3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderTileImageFeaturesEXT(const VkPhysicalDeviceShaderTileImageFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderTileImageColorReadAccess, settings, "VkBool32", "shaderTileImageColorReadAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderTileImageDepthReadAccess, settings, "VkBool32", "shaderTileImageDepthReadAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderTileImageStencilReadAccess, settings, "VkBool32", "shaderTileImageStencilReadAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderTileImagePropertiesEXT(const VkPhysicalDeviceShaderTileImagePropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderTileImageCoherentReadAccelerated, settings, "VkBool32", "shaderTileImageCoherentReadAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderTileImageReadSampleFromPixelRateInvocation, settings, "VkBool32", "shaderTileImageReadSampleFromPixelRateInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderTileImageReadFromHelperInvocation, settings, "VkBool32", "shaderTileImageReadFromHelperInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMicromapUsageEXT(const VkMicromapUsageEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.count, settings, "uint32_t", "count", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.subdivisionLevel, settings, "uint32_t", "subdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.format, settings, "uint32_t", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.hostAddress, settings, "void*", "hostAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMicromapBuildInfoEXT(const VkMicromapBuildInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMicromapTypeEXT<Format>(object.type, settings, "VkMicromapTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuildMicromapFlagsEXT<Format>(object.flags, settings, "VkBuildMicromapFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuildMicromapModeEXT<Format>(object.mode, settings, "VkBuildMicromapModeEXT", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMicromapEXT<Format>(object.dstMicromap, settings, "VkMicromapEXT", "dstMicromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.usageCountsCount, settings, "uint32_t", "usageCountsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pUsageCounts, object.usageCountsCount, settings, "const VkMicromapUsageEXT*", "pUsageCounts", "const VkMicromapUsageEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_double_pointer_array<Format>(object.ppUsageCounts, object.usageCountsCount * 1, settings, "const VkMicromapUsageEXT* const*", "ppUsageCounts", "const VkMicromapUsageEXT*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.data, settings, "VkDeviceOrHostAddressConstKHR", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressKHR<Format>(object.scratchData, settings, "VkDeviceOrHostAddressKHR", "scratchData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.triangleArray, settings, "VkDeviceOrHostAddressConstKHR", "triangleArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.triangleArrayStride, settings, "VkDeviceSize", "triangleArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMicromapCreateInfoEXT(const VkMicromapCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMicromapCreateFlagsEXT<Format>(object.createFlags, settings, "VkMicromapCreateFlagsEXT", "createFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMicromapTypeEXT<Format>(object.type, settings, "VkMicromapTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceOpacityMicromapFeaturesEXT(const VkPhysicalDeviceOpacityMicromapFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.micromap, settings, "VkBool32", "micromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.micromapCaptureReplay, settings, "VkBool32", "micromapCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.micromapHostCommands, settings, "VkBool32", "micromapHostCommands", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceOpacityMicromapPropertiesEXT(const VkPhysicalDeviceOpacityMicromapPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxOpacity2StateSubdivisionLevel, settings, "uint32_t", "maxOpacity2StateSubdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxOpacity4StateSubdivisionLevel, settings, "uint32_t", "maxOpacity4StateSubdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMicromapVersionInfoEXT(const VkMicromapVersionInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pVersionData, 2 * VK_UUID_SIZE, settings, "const uint8_t*", "pVersionData", "const uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint8_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyMicromapToMemoryInfoEXT(const VkCopyMicromapToMemoryInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMicromapEXT<Format>(object.src, settings, "VkMicromapEXT", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressKHR<Format>(object.dst, settings, "VkDeviceOrHostAddressKHR", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCopyMicromapModeEXT<Format>(object.mode, settings, "VkCopyMicromapModeEXT", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyMemoryToMicromapInfoEXT(const VkCopyMemoryToMicromapInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.src, settings, "VkDeviceOrHostAddressConstKHR", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMicromapEXT<Format>(object.dst, settings, "VkMicromapEXT", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCopyMicromapModeEXT<Format>(object.mode, settings, "VkCopyMicromapModeEXT", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyMicromapInfoEXT(const VkCopyMicromapInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMicromapEXT<Format>(object.src, settings, "VkMicromapEXT", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMicromapEXT<Format>(object.dst, settings, "VkMicromapEXT", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCopyMicromapModeEXT<Format>(object.mode, settings, "VkCopyMicromapModeEXT", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMicromapBuildSizesInfoEXT(const VkMicromapBuildSizesInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.micromapSize, settings, "VkDeviceSize", "micromapSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.buildScratchSize, settings, "VkDeviceSize", "buildScratchSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.discardable, settings, "VkBool32", "discardable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureTrianglesOpacityMicromapEXT(const VkAccelerationStructureTrianglesOpacityMicromapEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndexType<Format>(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.indexBuffer, settings, "VkDeviceOrHostAddressConstKHR", "indexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.baseTriangle, settings, "uint32_t", "baseTriangle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.usageCountsCount, settings, "uint32_t", "usageCountsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pUsageCounts, object.usageCountsCount, settings, "const VkMicromapUsageEXT*", "pUsageCounts", "const VkMicromapUsageEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_double_pointer_array<Format>(object.ppUsageCounts, object.usageCountsCount * 1, settings, "const VkMicromapUsageEXT* const*", "ppUsageCounts", "const VkMicromapUsageEXT*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_VkMicromapEXT<Format>(object.micromap, settings, "VkMicromapEXT", "micromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDisplacementMicromapFeaturesNV(const VkPhysicalDeviceDisplacementMicromapFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.displacementMicromap, settings, "VkBool32", "displacementMicromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDisplacementMicromapPropertiesNV(const VkPhysicalDeviceDisplacementMicromapPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDisplacementMicromapSubdivisionLevel, settings, "uint32_t", "maxDisplacementMicromapSubdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureTrianglesDisplacementMicromapNV(const VkAccelerationStructureTrianglesDisplacementMicromapNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.displacementBiasAndScaleFormat, settings, "VkFormat", "displacementBiasAndScaleFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.displacementVectorFormat, settings, "VkFormat", "displacementVectorFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.displacementBiasAndScaleBuffer, settings, "VkDeviceOrHostAddressConstKHR", "displacementBiasAndScaleBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.displacementBiasAndScaleStride, settings, "VkDeviceSize", "displacementBiasAndScaleStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.displacementVectorBuffer, settings, "VkDeviceOrHostAddressConstKHR", "displacementVectorBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.displacementVectorStride, settings, "VkDeviceSize", "displacementVectorStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.displacedMicromapPrimitiveFlags, settings, "VkDeviceOrHostAddressConstKHR", "displacedMicromapPrimitiveFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.displacedMicromapPrimitiveFlagsStride, settings, "VkDeviceSize", "displacedMicromapPrimitiveFlagsStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndexType<Format>(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.indexBuffer, settings, "VkDeviceOrHostAddressConstKHR", "indexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.baseTriangle, settings, "uint32_t", "baseTriangle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.usageCountsCount, settings, "uint32_t", "usageCountsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pUsageCounts, object.usageCountsCount, settings, "const VkMicromapUsageEXT*", "pUsageCounts", "const VkMicromapUsageEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_double_pointer_array<Format>(object.ppUsageCounts, object.usageCountsCount * 1, settings, "const VkMicromapUsageEXT* const*", "ppUsageCounts", "const VkMicromapUsageEXT*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_VkMicromapEXT<Format>(object.micromap, settings, "VkMicromapEXT", "micromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_ENABLE_BETA_EXTENSIONS
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.clustercullingShader, settings, "VkBool32", "clustercullingShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiviewClusterCullingShader, settings, "VkBool32", "multiviewClusterCullingShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxWorkGroupCount, 3, settings, "uint32_t[3]", "maxWorkGroupCount", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxWorkGroupSize, 3, settings, "uint32_t[3]", "maxWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxOutputClusterCount, settings, "uint32_t", "maxOutputClusterCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.indirectBufferOffsetAlignment, settings, "VkDeviceSize", "indirectBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.clusterShadingRate, settings, "VkBool32", "clusterShadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.borderColorSwizzle, settings, "VkBool32", "borderColorSwizzle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.borderColorSwizzleFromImage, settings, "VkBool32", "borderColorSwizzleFromImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerBorderColorComponentMappingCreateInfoEXT(const VkSamplerBorderColorComponentMappingCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentMapping<Format>(object.components, settings, "VkComponentMapping", "components", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.srgb, settings, "VkBool32", "srgb", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pageableDeviceLocalMemory, settings, "VkBool32", "pageableDeviceLocalMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderCorePropertiesARM(const VkPhysicalDeviceShaderCorePropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pixelRate, settings, "uint32_t", "pixelRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.texelRate, settings, "uint32_t", "texelRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.fmaRate, settings, "uint32_t", "fmaRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceQueueShaderCoreControlCreateInfoARM(const VkDeviceQueueShaderCoreControlCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderCoreCount, settings, "uint32_t", "shaderCoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSchedulingControlsFeaturesARM(const VkPhysicalDeviceSchedulingControlsFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.schedulingControls, settings, "VkBool32", "schedulingControls", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSchedulingControlsPropertiesARM(const VkPhysicalDeviceSchedulingControlsPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceSchedulingControlsFlagsARM<Format>(object.schedulingControlsFlags, settings, "VkPhysicalDeviceSchedulingControlsFlagsARM", "schedulingControlsFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDispatchParametersARM(const VkDispatchParametersARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.workGroupBatchSize, settings, "uint32_t", "workGroupBatchSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxQueuedWorkGroupBatches, settings, "uint32_t", "maxQueuedWorkGroupBatches", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxWarpsPerShaderCore, settings, "uint32_t", "maxWarpsPerShaderCore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM(const VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.schedulingControlsMaxWarpsCount, settings, "uint32_t", "schedulingControlsMaxWarpsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.schedulingControlsMaxQueuedBatchesCount, settings, "uint32_t", "schedulingControlsMaxQueuedBatchesCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.schedulingControlsMaxWorkGroupBatchSize, settings, "uint32_t", "schedulingControlsMaxWorkGroupBatchSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imageSlicedViewOf3D, settings, "VkBool32", "imageSlicedViewOf3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageViewSlicedCreateInfoEXT(const VkImageViewSlicedCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sliceOffset, settings, "uint32_t", "sliceOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.sliceCount, settings, "uint32_t", "sliceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorSetHostMapping, settings, "VkBool32", "descriptorSetHostMapping", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorSetBindingReferenceVALVE(const VkDescriptorSetBindingReferenceVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDescriptorSetLayout<Format>(object.descriptorSetLayout, settings, "VkDescriptorSetLayout", "descriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorSetLayoutHostMappingInfoVALVE(const VkDescriptorSetLayoutHostMappingInfoVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.descriptorOffset, settings, "size_t", "descriptorOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorSize, settings, "uint32_t", "descriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nonSeamlessCubeMap, settings, "VkBool32", "nonSeamlessCubeMap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRenderPassStripedFeaturesARM(const VkPhysicalDeviceRenderPassStripedFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.renderPassStriped, settings, "VkBool32", "renderPassStriped", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRenderPassStripedPropertiesARM(const VkPhysicalDeviceRenderPassStripedPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.renderPassStripeGranularity, settings, "VkExtent2D", "renderPassStripeGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxRenderPassStripes, settings, "uint32_t", "maxRenderPassStripes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassStripeInfoARM(const VkRenderPassStripeInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRect2D<Format>(object.stripeArea, settings, "VkRect2D", "stripeArea", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassStripeBeginInfoARM(const VkRenderPassStripeBeginInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stripeInfoCount, settings, "uint32_t", "stripeInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStripeInfos, object.stripeInfoCount, settings, "const VkRenderPassStripeInfoARM*", "pStripeInfos", "const VkRenderPassStripeInfoARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderPassStripeInfoARM<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassStripeSubmitInfoARM(const VkRenderPassStripeSubmitInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stripeSemaphoreInfoCount, settings, "uint32_t", "stripeSemaphoreInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStripeSemaphoreInfos, object.stripeSemaphoreInfoCount, settings, "const VkSemaphoreSubmitInfo*", "pStripeSemaphoreInfos", "const VkSemaphoreSubmitInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphoreSubmitInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentDensityMapOffset, settings, "VkBool32", "fragmentDensityMapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.fragmentDensityOffsetGranularity, settings, "VkExtent2D", "fragmentDensityOffsetGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassFragmentDensityMapOffsetEndInfoEXT(const VkRenderPassFragmentDensityMapOffsetEndInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.fragmentDensityOffsetCount, settings, "uint32_t", "fragmentDensityOffsetCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pFragmentDensityOffsets, object.fragmentDensityOffsetCount, settings, "const VkOffset2D*", "pFragmentDensityOffsets", "const VkOffset2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset2D<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.indirectCopy, settings, "VkBool32", "indirectCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDecompressMemoryRegionNV(const VkDecompressMemoryRegionNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.srcAddress, settings, "VkDeviceAddress", "srcAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.dstAddress, settings, "VkDeviceAddress", "dstAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.compressedSize, settings, "VkDeviceSize", "compressedSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.decompressedSize, settings, "VkDeviceSize", "decompressedSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMemoryDecompressionMethodFlagsEXT<Format>(object.decompressionMethod, settings, "VkMemoryDecompressionMethodFlagsEXT", "decompressionMethod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMemoryDecompressionFeaturesEXT(const VkPhysicalDeviceMemoryDecompressionFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.memoryDecompression, settings, "VkBool32", "memoryDecompression", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMemoryDecompressionPropertiesEXT(const VkPhysicalDeviceMemoryDecompressionPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMemoryDecompressionMethodFlagsEXT<Format>(object.decompressionMethods, settings, "VkMemoryDecompressionMethodFlagsEXT", "decompressionMethods", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxDecompressionIndirectCount, settings, "uint64_t", "maxDecompressionIndirectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceGeneratedCompute, settings, "VkBool32", "deviceGeneratedCompute", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceGeneratedComputePipelines, settings, "VkBool32", "deviceGeneratedComputePipelines", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceGeneratedComputeCaptureReplay, settings, "VkBool32", "deviceGeneratedComputeCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkComputePipelineIndirectBufferInfoNV(const VkComputePipelineIndirectBufferInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.pipelineDeviceAddressCaptureReplay, settings, "VkDeviceAddress", "pipelineDeviceAddressCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineIndirectDeviceAddressInfoNV(const VkPipelineIndirectDeviceAddressInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineBindPoint<Format>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindPipelineIndirectCommandNV(const VkBindPipelineIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.pipelineAddress, settings, "VkDeviceAddress", "pipelineAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.spheres, settings, "VkBool32", "spheres", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.linearSweptSpheres, settings, "VkBool32", "linearSweptSpheres", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(const VkAccelerationStructureGeometryLinearSweptSpheresDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.radiusFormat, settings, "VkFormat", "radiusFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.radiusData, settings, "VkDeviceOrHostAddressConstKHR", "radiusData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.radiusStride, settings, "VkDeviceSize", "radiusStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndexType<Format>(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.indexData, settings, "VkDeviceOrHostAddressConstKHR", "indexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRayTracingLssIndexingModeNV<Format>(object.indexingMode, settings, "VkRayTracingLssIndexingModeNV", "indexingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRayTracingLssPrimitiveEndCapsModeNV<Format>(object.endCapsMode, settings, "VkRayTracingLssPrimitiveEndCapsModeNV", "endCapsMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureGeometrySpheresDataNV(const VkAccelerationStructureGeometrySpheresDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.radiusFormat, settings, "VkFormat", "radiusFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.radiusData, settings, "VkDeviceOrHostAddressConstKHR", "radiusData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.radiusStride, settings, "VkDeviceSize", "radiusStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndexType<Format>(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.indexData, settings, "VkDeviceOrHostAddressConstKHR", "indexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(const VkPhysicalDeviceLinearColorAttachmentFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.linearColorAttachment, settings, "VkBool32", "linearColorAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imageCompressionControlSwapchain, settings, "VkBool32", "imageCompressionControlSwapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageViewSampleWeightCreateInfoQCOM(const VkImageViewSampleWeightCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset2D<Format>(object.filterCenter, settings, "VkOffset2D", "filterCenter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.filterSize, settings, "VkExtent2D", "filterSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numPhases, settings, "uint32_t", "numPhases", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageProcessingFeaturesQCOM(const VkPhysicalDeviceImageProcessingFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.textureSampleWeighted, settings, "VkBool32", "textureSampleWeighted", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.textureBoxFilter, settings, "VkBool32", "textureBoxFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.textureBlockMatch, settings, "VkBool32", "textureBlockMatch", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageProcessingPropertiesQCOM(const VkPhysicalDeviceImageProcessingPropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxWeightFilterPhases, settings, "uint32_t", "maxWeightFilterPhases", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxWeightFilterDimension, settings, "VkExtent2D", "maxWeightFilterDimension", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxBlockMatchRegion, settings, "VkExtent2D", "maxBlockMatchRegion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxBoxFilterBlockSize, settings, "VkExtent2D", "maxBoxFilterBlockSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(const VkPhysicalDeviceNestedCommandBufferFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nestedCommandBuffer, settings, "VkBool32", "nestedCommandBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nestedCommandBufferRendering, settings, "VkBool32", "nestedCommandBufferRendering", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nestedCommandBufferSimultaneousUse, settings, "VkBool32", "nestedCommandBufferSimultaneousUse", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(const VkPhysicalDeviceNestedCommandBufferPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxCommandBufferNestingLevel, settings, "uint32_t", "maxCommandBufferNestingLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_OHOS)
template <ApiDumpFormat Format>
void dump_VkNativeBufferUsageOHOS(const VkNativeBufferUsageOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.OHOSNativeBufferUsage, settings, "uint64_t", "OHOSNativeBufferUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkNativeBufferPropertiesOHOS(const VkNativeBufferPropertiesOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.allocationSize, settings, "VkDeviceSize", "allocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkNativeBufferFormatPropertiesOHOS(const VkNativeBufferFormatPropertiesOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags<Format>(object.formatFeatures, settings, "VkFormatFeatureFlags", "formatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentMapping<Format>(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrModelConversion<Format>(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrRange<Format>(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImportNativeBufferInfoOHOS(const VkImportNativeBufferInfoOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, struct OH_NativeBuffer*>(object.buffer, settings, "struct OH_NativeBuffer*", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryGetNativeBufferInfoOHOS(const VkMemoryGetNativeBufferInfoOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalFormatOHOS(const VkExternalFormatOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_OHOS
template <ApiDumpFormat Format>
void dump_VkExternalMemoryAcquireUnmodifiedEXT(const VkExternalMemoryAcquireUnmodifiedEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.acquireUnmodifiedMemory, settings, "VkBool32", "acquireUnmodifiedMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3TessellationDomainOrigin, settings, "VkBool32", "extendedDynamicState3TessellationDomainOrigin", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3DepthClampEnable, settings, "VkBool32", "extendedDynamicState3DepthClampEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3PolygonMode, settings, "VkBool32", "extendedDynamicState3PolygonMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3RasterizationSamples, settings, "VkBool32", "extendedDynamicState3RasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3SampleMask, settings, "VkBool32", "extendedDynamicState3SampleMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3AlphaToCoverageEnable, settings, "VkBool32", "extendedDynamicState3AlphaToCoverageEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3AlphaToOneEnable, settings, "VkBool32", "extendedDynamicState3AlphaToOneEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3LogicOpEnable, settings, "VkBool32", "extendedDynamicState3LogicOpEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3ColorBlendEnable, settings, "VkBool32", "extendedDynamicState3ColorBlendEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3ColorBlendEquation, settings, "VkBool32", "extendedDynamicState3ColorBlendEquation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3ColorWriteMask, settings, "VkBool32", "extendedDynamicState3ColorWriteMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3RasterizationStream, settings, "VkBool32", "extendedDynamicState3RasterizationStream", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3ConservativeRasterizationMode, settings, "VkBool32", "extendedDynamicState3ConservativeRasterizationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3ExtraPrimitiveOverestimationSize, settings, "VkBool32", "extendedDynamicState3ExtraPrimitiveOverestimationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3DepthClipEnable, settings, "VkBool32", "extendedDynamicState3DepthClipEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3SampleLocationsEnable, settings, "VkBool32", "extendedDynamicState3SampleLocationsEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3ColorBlendAdvanced, settings, "VkBool32", "extendedDynamicState3ColorBlendAdvanced", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3ProvokingVertexMode, settings, "VkBool32", "extendedDynamicState3ProvokingVertexMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3LineRasterizationMode, settings, "VkBool32", "extendedDynamicState3LineRasterizationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3LineStippleEnable, settings, "VkBool32", "extendedDynamicState3LineStippleEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3DepthClipNegativeOneToOne, settings, "VkBool32", "extendedDynamicState3DepthClipNegativeOneToOne", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3ViewportWScalingEnable, settings, "VkBool32", "extendedDynamicState3ViewportWScalingEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3ViewportSwizzle, settings, "VkBool32", "extendedDynamicState3ViewportSwizzle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3CoverageToColorEnable, settings, "VkBool32", "extendedDynamicState3CoverageToColorEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3CoverageToColorLocation, settings, "VkBool32", "extendedDynamicState3CoverageToColorLocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3CoverageModulationMode, settings, "VkBool32", "extendedDynamicState3CoverageModulationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3CoverageModulationTableEnable, settings, "VkBool32", "extendedDynamicState3CoverageModulationTableEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3CoverageModulationTable, settings, "VkBool32", "extendedDynamicState3CoverageModulationTable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3CoverageReductionMode, settings, "VkBool32", "extendedDynamicState3CoverageReductionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3RepresentativeFragmentTestEnable, settings, "VkBool32", "extendedDynamicState3RepresentativeFragmentTestEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedDynamicState3ShadingRateImageEnable, settings, "VkBool32", "extendedDynamicState3ShadingRateImageEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dynamicPrimitiveTopologyUnrestricted, settings, "VkBool32", "dynamicPrimitiveTopologyUnrestricted", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkColorBlendEquationEXT(const VkColorBlendEquationEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkBlendFactor<Format>(object.srcColorBlendFactor, settings, "VkBlendFactor", "srcColorBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendFactor<Format>(object.dstColorBlendFactor, settings, "VkBlendFactor", "dstColorBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendOp<Format>(object.colorBlendOp, settings, "VkBlendOp", "colorBlendOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendFactor<Format>(object.srcAlphaBlendFactor, settings, "VkBlendFactor", "srcAlphaBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendFactor<Format>(object.dstAlphaBlendFactor, settings, "VkBlendFactor", "dstAlphaBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendOp<Format>(object.alphaBlendOp, settings, "VkBlendOp", "alphaBlendOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkColorBlendAdvancedEXT(const VkColorBlendAdvancedEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkBlendOp<Format>(object.advancedBlendOp, settings, "VkBlendOp", "advancedBlendOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.srcPremultiplied, settings, "VkBool32", "srcPremultiplied", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dstPremultiplied, settings, "VkBool32", "dstPremultiplied", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlendOverlapEXT<Format>(object.blendOverlap, settings, "VkBlendOverlapEXT", "blendOverlap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.clampResults, settings, "VkBool32", "clampResults", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.subpassMergeFeedback, settings, "VkBool32", "subpassMergeFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassCreationControlEXT(const VkRenderPassCreationControlEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.disallowMerging, settings, "VkBool32", "disallowMerging", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassCreationFeedbackInfoEXT(const VkRenderPassCreationFeedbackInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.postMergeSubpassCount, settings, "uint32_t", "postMergeSubpassCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassCreationFeedbackCreateInfoEXT(const VkRenderPassCreationFeedbackCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pRenderPassFeedback, settings, "VkRenderPassCreationFeedbackInfoEXT*", "pRenderPassFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderPassCreationFeedbackInfoEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassSubpassFeedbackInfoEXT(const VkRenderPassSubpassFeedbackInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkSubpassMergeStatusEXT<Format>(object.subpassMergeStatus, settings, "VkSubpassMergeStatusEXT", "subpassMergeStatus", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.postMergeIndex, settings, "uint32_t", "postMergeIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassSubpassFeedbackCreateInfoEXT(const VkRenderPassSubpassFeedbackCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSubpassFeedback, settings, "VkRenderPassSubpassFeedbackInfoEXT*", "pSubpassFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderPassSubpassFeedbackInfoEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDirectDriverLoadingInfoLUNARG(const VkDirectDriverLoadingInfoLUNARG& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDirectDriverLoadingFlagsLUNARG<Format>(object.flags, settings, "VkDirectDriverLoadingFlagsLUNARG", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_PFN_vkGetInstanceProcAddrLUNARG<Format>(object.pfnGetInstanceProcAddr, settings, "PFN_vkGetInstanceProcAddrLUNARG", "pfnGetInstanceProcAddr", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDirectDriverLoadingListLUNARG(const VkDirectDriverLoadingListLUNARG& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDirectDriverLoadingModeLUNARG<Format>(object.mode, settings, "VkDirectDriverLoadingModeLUNARG", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.driverCount, settings, "uint32_t", "driverCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDrivers, object.driverCount, settings, "const VkDirectDriverLoadingInfoLUNARG*", "pDrivers", "const VkDirectDriverLoadingInfoLUNARG", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDirectDriverLoadingInfoLUNARG<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorDescriptionARM(const VkTensorDescriptionARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorTilingARM<Format>(object.tiling, settings, "VkTensorTilingARM", "tiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dimensionCount, settings, "uint32_t", "dimensionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDimensions, object.dimensionCount, settings, "const int64_t*", "pDimensions", "const int64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const int64_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStrides, object.dimensionCount, settings, "const int64_t*", "pStrides", "const int64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const int64_t>);
    dump_separate_members<Format>(settings);
    dump_VkTensorUsageFlagsARM<Format>(object.usage, settings, "VkTensorUsageFlagsARM", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorCreateInfoARM(const VkTensorCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorCreateFlagsARM<Format>(object.flags, settings, "VkTensorCreateFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDescription, settings, "const VkTensorDescriptionARM*", "pDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorDescriptionARM<Format>);
    dump_separate_members<Format>(settings);
    dump_VkSharingMode<Format>(object.sharingMode, settings, "VkSharingMode", "sharingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorMemoryRequirementsInfoARM(const VkTensorMemoryRequirementsInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorARM<Format>(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindTensorMemoryInfoARM(const VkBindTensorMemoryInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorARM<Format>(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkWriteDescriptorSetTensorARM(const VkWriteDescriptorSetTensorARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tensorViewCount, settings, "uint32_t", "tensorViewCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTensorViews, object.tensorViewCount, settings, "const VkTensorViewARM*", "pTensorViews", "const VkTensorViewARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorViewARM<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorFormatPropertiesARM(const VkTensorFormatPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.optimalTilingTensorFeatures, settings, "VkFormatFeatureFlags2", "optimalTilingTensorFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.linearTilingTensorFeatures, settings, "VkFormatFeatureFlags2", "linearTilingTensorFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTensorPropertiesARM(const VkPhysicalDeviceTensorPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTensorDimensionCount, settings, "uint32_t", "maxTensorDimensionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxTensorElements, settings, "uint64_t", "maxTensorElements", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxPerDimensionTensorElements, settings, "uint64_t", "maxPerDimensionTensorElements", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int64_t>(object.maxTensorStride, settings, "int64_t", "maxTensorStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxTensorSize, settings, "uint64_t", "maxTensorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTensorShaderAccessArrayLength, settings, "uint32_t", "maxTensorShaderAccessArrayLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTensorShaderAccessSize, settings, "uint32_t", "maxTensorShaderAccessSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetStorageTensors, settings, "uint32_t", "maxDescriptorSetStorageTensors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorSetStorageTensors, settings, "uint32_t", "maxPerStageDescriptorSetStorageTensors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageTensors, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageTensors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindStorageTensors, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageTensors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageTensorArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageTensorArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.shaderTensorSupportedStages, settings, "VkShaderStageFlags", "shaderTensorSupportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorMemoryBarrierARM(const VkTensorMemoryBarrierARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags2<Format>(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineStageFlags2<Format>(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccessFlags2<Format>(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorARM<Format>(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorDependencyInfoARM(const VkTensorDependencyInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tensorMemoryBarrierCount, settings, "uint32_t", "tensorMemoryBarrierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTensorMemoryBarriers, object.tensorMemoryBarrierCount, settings, "const VkTensorMemoryBarrierARM*", "pTensorMemoryBarriers", "const VkTensorMemoryBarrierARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorMemoryBarrierARM<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTensorFeaturesARM(const VkPhysicalDeviceTensorFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tensorNonPacked, settings, "VkBool32", "tensorNonPacked", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderTensorAccess, settings, "VkBool32", "shaderTensorAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageTensorArrayDynamicIndexing, settings, "VkBool32", "shaderStorageTensorArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderStorageTensorArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageTensorArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingStorageTensorUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageTensorUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tensors, settings, "VkBool32", "tensors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDeviceTensorMemoryRequirementsARM(const VkDeviceTensorMemoryRequirementsARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pCreateInfo, settings, "const VkTensorCreateInfoARM*", "pCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorCreateInfoARM<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorCopyARM(const VkTensorCopyARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dimensionCount, settings, "uint32_t", "dimensionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSrcOffset, object.dimensionCount, settings, "const uint64_t*", "pSrcOffset", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pDstOffset, object.dimensionCount, settings, "const uint64_t*", "pDstOffset", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pExtent, object.dimensionCount, settings, "const uint64_t*", "pExtent", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint64_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyTensorInfoARM(const VkCopyTensorInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorARM<Format>(object.srcTensor, settings, "VkTensorARM", "srcTensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorARM<Format>(object.dstTensor, settings, "VkTensorARM", "dstTensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkTensorCopyARM*", "pRegions", "const VkTensorCopyARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorCopyARM<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryDedicatedAllocateInfoTensorARM(const VkMemoryDedicatedAllocateInfoTensorARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorARM<Format>(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExternalTensorInfoARM(const VkPhysicalDeviceExternalTensorInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorCreateFlagsARM<Format>(object.flags, settings, "VkTensorCreateFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDescription, settings, "const VkTensorDescriptionARM*", "pDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorDescriptionARM<Format>);
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalTensorPropertiesARM(const VkExternalTensorPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryProperties<Format>(object.externalMemoryProperties, settings, "VkExternalMemoryProperties", "externalMemoryProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalMemoryTensorCreateInfoARM(const VkExternalMemoryTensorCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlags<Format>(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBufferTensorDescriptors, settings, "VkBool32", "descriptorBufferTensorDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.tensorCaptureReplayDescriptorDataSize, settings, "size_t", "tensorCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.tensorViewCaptureReplayDescriptorDataSize, settings, "size_t", "tensorViewCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.tensorDescriptorSize, settings, "size_t", "tensorDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDescriptorGetTensorInfoARM(const VkDescriptorGetTensorInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorViewARM<Format>(object.tensorView, settings, "VkTensorViewARM", "tensorView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorCaptureDescriptorDataInfoARM(const VkTensorCaptureDescriptorDataInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorARM<Format>(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorViewCaptureDescriptorDataInfoARM(const VkTensorViewCaptureDescriptorDataInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkTensorViewARM<Format>(object.tensorView, settings, "VkTensorViewARM", "tensorView", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkFrameBoundaryTensorsARM(const VkFrameBoundaryTensorsARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tensorCount, settings, "uint32_t", "tensorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTensors, object.tensorCount, settings, "const VkTensorARM*", "pTensors", "const VkTensorARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorARM<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderModuleIdentifier, settings, "VkBool32", "shaderModuleIdentifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "shaderModuleIdentifierAlgorithmUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.identifierSize, settings, "uint32_t", "identifierSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pIdentifier, object.identifierSize, settings, "const uint8_t*", "pIdentifier", "const uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint8_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderModuleIdentifierEXT(const VkShaderModuleIdentifierEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.identifierSize, settings, "uint32_t", "identifierSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.identifier, std::min(object.identifierSize, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT), settings, "uint8_t[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]", "identifier", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceOpticalFlowFeaturesNV(const VkPhysicalDeviceOpticalFlowFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.opticalFlow, settings, "VkBool32", "opticalFlow", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceOpticalFlowPropertiesNV(const VkPhysicalDeviceOpticalFlowPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOpticalFlowGridSizeFlagsNV<Format>(object.supportedOutputGridSizes, settings, "VkOpticalFlowGridSizeFlagsNV", "supportedOutputGridSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOpticalFlowGridSizeFlagsNV<Format>(object.supportedHintGridSizes, settings, "VkOpticalFlowGridSizeFlagsNV", "supportedHintGridSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hintSupported, settings, "VkBool32", "hintSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.costSupported, settings, "VkBool32", "costSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.bidirectionalFlowSupported, settings, "VkBool32", "bidirectionalFlowSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.globalFlowSupported, settings, "VkBool32", "globalFlowSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minWidth, settings, "uint32_t", "minWidth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minHeight, settings, "uint32_t", "minHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxWidth, settings, "uint32_t", "maxWidth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxHeight, settings, "uint32_t", "maxHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxNumRegionsOfInterest, settings, "uint32_t", "maxNumRegionsOfInterest", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkOpticalFlowImageFormatInfoNV(const VkOpticalFlowImageFormatInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOpticalFlowUsageFlagsNV<Format>(object.usage, settings, "VkOpticalFlowUsageFlagsNV", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkOpticalFlowImageFormatPropertiesNV(const VkOpticalFlowImageFormatPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkOpticalFlowSessionCreateInfoNV(const VkOpticalFlowSessionCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.imageFormat, settings, "VkFormat", "imageFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.flowVectorFormat, settings, "VkFormat", "flowVectorFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.costFormat, settings, "VkFormat", "costFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOpticalFlowGridSizeFlagsNV<Format>(object.outputGridSize, settings, "VkOpticalFlowGridSizeFlagsNV", "outputGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOpticalFlowGridSizeFlagsNV<Format>(object.hintGridSize, settings, "VkOpticalFlowGridSizeFlagsNV", "hintGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOpticalFlowPerformanceLevelNV<Format>(object.performanceLevel, settings, "VkOpticalFlowPerformanceLevelNV", "performanceLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOpticalFlowSessionCreateFlagsNV<Format>(object.flags, settings, "VkOpticalFlowSessionCreateFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkOpticalFlowSessionCreatePrivateDataInfoNV(const VkOpticalFlowSessionCreatePrivateDataInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.id, settings, "uint32_t", "id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pPrivateData, settings, "const void*", "pPrivateData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkOpticalFlowExecuteInfoNV(const VkOpticalFlowExecuteInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOpticalFlowExecuteFlagsNV<Format>(object.flags, settings, "VkOpticalFlowExecuteFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkRect2D*", "pRegions", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLegacyDitheringFeaturesEXT(const VkPhysicalDeviceLegacyDitheringFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.legacyDithering, settings, "VkBool32", "legacyDithering", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.externalFormatResolve, settings, "VkBool32", "externalFormatResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nullColorAttachmentWithExternalFormatResolve, settings, "VkBool32", "nullColorAttachmentWithExternalFormatResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.externalFormatResolveChromaOffsetX, settings, "VkChromaLocation", "externalFormatResolveChromaOffsetX", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.externalFormatResolveChromaOffsetY, settings, "VkChromaLocation", "externalFormatResolveChromaOffsetY", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(const VkAndroidHardwareBufferFormatResolvePropertiesANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.colorAttachmentFormat, settings, "VkFormat", "colorAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_ANDROID_KHR
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceAntiLagFeaturesAMD(const VkPhysicalDeviceAntiLagFeaturesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.antiLag, settings, "VkBool32", "antiLag", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAntiLagPresentationInfoAMD(const VkAntiLagPresentationInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAntiLagStageAMD<Format>(object.stage, settings, "VkAntiLagStageAMD", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.frameIndex, settings, "uint64_t", "frameIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAntiLagDataAMD(const VkAntiLagDataAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAntiLagModeAMD<Format>(object.mode, settings, "VkAntiLagModeAMD", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFPS, settings, "uint32_t", "maxFPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pPresentationInfo, settings, "const VkAntiLagPresentationInfoAMD*", "pPresentationInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAntiLagPresentationInfoAMD<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX(const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.denseGeometryFormat, settings, "VkBool32", "denseGeometryFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX(const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.compressedData, settings, "VkDeviceOrHostAddressConstKHR", "compressedData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.dataSize, settings, "VkDeviceSize", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numTriangles, settings, "uint32_t", "numTriangles", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numVertices, settings, "uint32_t", "numVertices", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPrimitiveIndex, settings, "uint32_t", "maxPrimitiveIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGeometryIndex, settings, "uint32_t", "maxGeometryIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCompressedTriangleFormatAMDX<Format>(object.format, settings, "VkCompressedTriangleFormatAMDX", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_ENABLE_BETA_EXTENSIONS
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderObjectFeaturesEXT(const VkPhysicalDeviceShaderObjectFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderObject, settings, "VkBool32", "shaderObject", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderObjectPropertiesEXT(const VkPhysicalDeviceShaderObjectPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.shaderBinaryUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "shaderBinaryUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderBinaryVersion, settings, "uint32_t", "shaderBinaryVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderCreateInfoEXT(const VkShaderCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderCreateFlagsEXT<Format>(object.flags, settings, "VkShaderCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlagBits<Format>(object.stage, settings, "VkShaderStageFlagBits", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.nextStage, settings, "VkShaderStageFlags", "nextStage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderCodeTypeEXT<Format>(object.codeType, settings, "VkShaderCodeTypeEXT", "codeType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.codeSize, settings, "size_t", "codeSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);

    if (settings.showShader()) {
        dump_spirv<Format>(object.pCode, object.codeSize, settings, "const void*", "pCode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    } else {
        dump_special<Format>("SHADER DATA", settings, "const void*", "pCode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    }
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.setLayoutCount, settings, "uint32_t", "setLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSetLayouts, object.setLayoutCount, settings, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pushConstantRangeCount, settings, "uint32_t", "pushConstantRangeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPushConstantRanges, object.pushConstantRangeCount, settings, "const VkPushConstantRange*", "pPushConstantRanges", "const VkPushConstantRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPushConstantRange<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSpecializationInfo, settings, "const VkSpecializationInfo*", "pSpecializationInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationInfo<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDepthClampRangeEXT(const VkDepthClampRangeEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, float>(object.minDepthClamp, settings, "float", "minDepthClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.maxDepthClamp, settings, "float", "maxDepthClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTilePropertiesFeaturesQCOM(const VkPhysicalDeviceTilePropertiesFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileProperties, settings, "VkBool32", "tileProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTilePropertiesQCOM(const VkTilePropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent3D<Format>(object.tileSize, settings, "VkExtent3D", "tileSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.apronSize, settings, "VkExtent2D", "apronSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOffset2D<Format>(object.origin, settings, "VkOffset2D", "origin", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceAmigoProfilingFeaturesSEC(const VkPhysicalDeviceAmigoProfilingFeaturesSEC& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.amigoProfiling, settings, "VkBool32", "amigoProfiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAmigoProfilingSubmitInfoSEC(const VkAmigoProfilingSubmitInfoSEC& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.firstDrawTimestamp, settings, "uint64_t", "firstDrawTimestamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.swapBufferTimestamp, settings, "uint64_t", "swapBufferTimestamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiviewPerViewViewports, settings, "VkBool32", "multiviewPerViewViewports", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRayTracingInvocationReorderModeEXT<Format>(object.rayTracingInvocationReorderReorderingHint, settings, "VkRayTracingInvocationReorderModeEXT", "rayTracingInvocationReorderReorderingHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingInvocationReorder, settings, "VkBool32", "rayTracingInvocationReorder", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCooperativeVectorPropertiesNV(const VkPhysicalDeviceCooperativeVectorPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.cooperativeVectorSupportedStages, settings, "VkShaderStageFlags", "cooperativeVectorSupportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeVectorTrainingFloat16Accumulation, settings, "VkBool32", "cooperativeVectorTrainingFloat16Accumulation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeVectorTrainingFloat32Accumulation, settings, "VkBool32", "cooperativeVectorTrainingFloat32Accumulation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxCooperativeVectorComponents, settings, "uint32_t", "maxCooperativeVectorComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCooperativeVectorFeaturesNV(const VkPhysicalDeviceCooperativeVectorFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeVector, settings, "VkBool32", "cooperativeVector", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeVectorTraining, settings, "VkBool32", "cooperativeVectorTraining", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCooperativeVectorPropertiesNV(const VkCooperativeVectorPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.inputType, settings, "VkComponentTypeKHR", "inputType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.inputInterpretation, settings, "VkComponentTypeKHR", "inputInterpretation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.matrixInterpretation, settings, "VkComponentTypeKHR", "matrixInterpretation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.biasInterpretation, settings, "VkComponentTypeKHR", "biasInterpretation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.resultType, settings, "VkComponentTypeKHR", "resultType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.transpose, settings, "VkBool32", "transpose", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkConvertCooperativeVectorMatrixInfoNV(const VkConvertCooperativeVectorMatrixInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.srcSize, settings, "size_t", "srcSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.srcData, settings, "VkDeviceOrHostAddressConstKHR", "srcData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDstSize, settings, "size_t*", "pDstSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, size_t>);
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressKHR<Format>(object.dstData, settings, "VkDeviceOrHostAddressKHR", "dstData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.srcComponentType, settings, "VkComponentTypeKHR", "srcComponentType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.dstComponentType, settings, "VkComponentTypeKHR", "dstComponentType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numRows, settings, "uint32_t", "numRows", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numColumns, settings, "uint32_t", "numColumns", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCooperativeVectorMatrixLayoutNV<Format>(object.srcLayout, settings, "VkCooperativeVectorMatrixLayoutNV", "srcLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.srcStride, settings, "size_t", "srcStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCooperativeVectorMatrixLayoutNV<Format>(object.dstLayout, settings, "VkCooperativeVectorMatrixLayoutNV", "dstLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.dstStride, settings, "size_t", "dstStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.extendedSparseAddressSpace, settings, "VkBool32", "extendedSparseAddressSpace", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.extendedSparseAddressSpaceSize, settings, "VkDeviceSize", "extendedSparseAddressSpaceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageUsageFlags<Format>(object.extendedSparseImageUsageFlags, settings, "VkImageUsageFlags", "extendedSparseImageUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBufferUsageFlags<Format>(object.extendedSparseBufferUsageFlags, settings, "VkBufferUsageFlags", "extendedSparseBufferUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.legacyVertexAttributes, settings, "VkBool32", "legacyVertexAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.nativeUnalignedPerformance, settings, "VkBool32", "nativeUnalignedPerformance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkLayerSettingEXT(const VkLayerSettingEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_char<Format>(object.pLayerName, settings, "const char*", "pLayerName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pSettingName, settings, "const char*", "pSettingName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkLayerSettingTypeEXT<Format>(object.type, settings, "VkLayerSettingTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.valueCount, settings, "uint32_t", "valueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pValues, settings, "const void*", "pValues", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkLayerSettingsCreateInfoEXT(const VkLayerSettingsCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.settingCount, settings, "uint32_t", "settingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSettings, object.settingCount, settings, "const VkLayerSettingEXT*", "pSettings", "const VkLayerSettingEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkLayerSettingEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderCoreBuiltins, settings, "VkBool32", "shaderCoreBuiltins", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.shaderCoreMask, settings, "uint64_t", "shaderCoreMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderCoreCount, settings, "uint32_t", "shaderCoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderWarpsPerCore, settings, "uint32_t", "shaderWarpsPerCore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineLibraryGroupHandles, settings, "VkBool32", "pipelineLibraryGroupHandles", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dynamicRenderingUnusedAttachments, settings, "VkBool32", "dynamicRenderingUnusedAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkLatencySleepModeInfoNV(const VkLatencySleepModeInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.lowLatencyMode, settings, "VkBool32", "lowLatencyMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.lowLatencyBoost, settings, "VkBool32", "lowLatencyBoost", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minimumIntervalUs, settings, "uint32_t", "minimumIntervalUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkLatencySleepInfoNV(const VkLatencySleepInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSemaphore<Format>(object.signalSemaphore, settings, "VkSemaphore", "signalSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.value, settings, "uint64_t", "value", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSetLatencyMarkerInfoNV(const VkSetLatencyMarkerInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.presentID, settings, "uint64_t", "presentID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkLatencyMarkerNV<Format>(object.marker, settings, "VkLatencyMarkerNV", "marker", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkLatencyTimingsFrameReportNV(const VkLatencyTimingsFrameReportNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.presentID, settings, "uint64_t", "presentID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.inputSampleTimeUs, settings, "uint64_t", "inputSampleTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.simStartTimeUs, settings, "uint64_t", "simStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.simEndTimeUs, settings, "uint64_t", "simEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.renderSubmitStartTimeUs, settings, "uint64_t", "renderSubmitStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.renderSubmitEndTimeUs, settings, "uint64_t", "renderSubmitEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.presentStartTimeUs, settings, "uint64_t", "presentStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.presentEndTimeUs, settings, "uint64_t", "presentEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.driverStartTimeUs, settings, "uint64_t", "driverStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.driverEndTimeUs, settings, "uint64_t", "driverEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.osRenderQueueStartTimeUs, settings, "uint64_t", "osRenderQueueStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.osRenderQueueEndTimeUs, settings, "uint64_t", "osRenderQueueEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.gpuRenderStartTimeUs, settings, "uint64_t", "gpuRenderStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.gpuRenderEndTimeUs, settings, "uint64_t", "gpuRenderEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGetLatencyMarkerInfoNV(const VkGetLatencyMarkerInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.timingCount, settings, "uint32_t", "timingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTimings, object.timingCount, settings, "VkLatencyTimingsFrameReportNV*", "pTimings", "VkLatencyTimingsFrameReportNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkLatencyTimingsFrameReportNV<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkLatencySubmissionPresentIdNV(const VkLatencySubmissionPresentIdNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.presentID, settings, "uint64_t", "presentID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainLatencyCreateInfoNV(const VkSwapchainLatencyCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.latencyModeEnable, settings, "VkBool32", "latencyModeEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkOutOfBandQueueTypeInfoNV(const VkOutOfBandQueueTypeInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkOutOfBandQueueTypeNV<Format>(object.queueType, settings, "VkOutOfBandQueueTypeNV", "queueType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkLatencySurfaceCapabilitiesNV(const VkLatencySurfaceCapabilitiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.presentModeCount, settings, "uint32_t", "presentModeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPresentModes, object.presentModeCount, settings, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDataGraphFeaturesARM(const VkPhysicalDeviceDataGraphFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dataGraph, settings, "VkBool32", "dataGraph", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dataGraphUpdateAfterBind, settings, "VkBool32", "dataGraphUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dataGraphSpecializationConstants, settings, "VkBool32", "dataGraphSpecializationConstants", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dataGraphDescriptorBuffer, settings, "VkBool32", "dataGraphDescriptorBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dataGraphShaderModule, settings, "VkBool32", "dataGraphShaderModule", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineConstantARM(const VkDataGraphPipelineConstantARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.id, settings, "uint32_t", "id", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pConstantData, settings, "const void*", "pConstantData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineResourceInfoARM(const VkDataGraphPipelineResourceInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.descriptorSet, settings, "uint32_t", "descriptorSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.arrayElement, settings, "uint32_t", "arrayElement", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineCompilerControlCreateInfoARM(const VkDataGraphPipelineCompilerControlCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pVendorOptions, settings, "const char*", "pVendorOptions", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineCreateInfoARM(const VkDataGraphPipelineCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCreateFlags2<Format>(object.flags, settings, "VkPipelineCreateFlags2", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.resourceInfoCount, settings, "uint32_t", "resourceInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pResourceInfos, object.resourceInfoCount, settings, "const VkDataGraphPipelineResourceInfoARM*", "pResourceInfos", "const VkDataGraphPipelineResourceInfoARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDataGraphPipelineResourceInfoARM<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineShaderModuleCreateInfoARM(const VkDataGraphPipelineShaderModuleCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderModule<Format>(object.module, settings, "VkShaderModule", "module", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pSpecializationInfo, settings, "const VkSpecializationInfo*", "pSpecializationInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.constantCount, settings, "uint32_t", "constantCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pConstants, object.constantCount, settings, "const VkDataGraphPipelineConstantARM*", "pConstants", "const VkDataGraphPipelineConstantARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDataGraphPipelineConstantARM<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSessionCreateInfoARM(const VkDataGraphPipelineSessionCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelineSessionCreateFlagsARM<Format>(object.flags, settings, "VkDataGraphPipelineSessionCreateFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.dataGraphPipeline, settings, "VkPipeline", "dataGraphPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSessionBindPointRequirementsInfoARM(const VkDataGraphPipelineSessionBindPointRequirementsInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelineSessionARM<Format>(object.session, settings, "VkDataGraphPipelineSessionARM", "session", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSessionBindPointRequirementARM(const VkDataGraphPipelineSessionBindPointRequirementARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelineSessionBindPointARM<Format>(object.bindPoint, settings, "VkDataGraphPipelineSessionBindPointARM", "bindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelineSessionBindPointTypeARM<Format>(object.bindPointType, settings, "VkDataGraphPipelineSessionBindPointTypeARM", "bindPointType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numObjects, settings, "uint32_t", "numObjects", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSessionMemoryRequirementsInfoARM(const VkDataGraphPipelineSessionMemoryRequirementsInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelineSessionARM<Format>(object.session, settings, "VkDataGraphPipelineSessionARM", "session", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelineSessionBindPointARM<Format>(object.bindPoint, settings, "VkDataGraphPipelineSessionBindPointARM", "bindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.objectIndex, settings, "uint32_t", "objectIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindDataGraphPipelineSessionMemoryInfoARM(const VkBindDataGraphPipelineSessionMemoryInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelineSessionARM<Format>(object.session, settings, "VkDataGraphPipelineSessionARM", "session", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelineSessionBindPointARM<Format>(object.bindPoint, settings, "VkDataGraphPipelineSessionBindPointARM", "bindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.objectIndex, settings, "uint32_t", "objectIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineInfoARM(const VkDataGraphPipelineInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.dataGraphPipeline, settings, "VkPipeline", "dataGraphPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelinePropertyQueryResultARM(const VkDataGraphPipelinePropertyQueryResultARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelinePropertyARM<Format>(object.property, settings, "VkDataGraphPipelinePropertyARM", "property", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.isText, settings, "VkBool32", "isText", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.pData, settings, "void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineIdentifierCreateInfoARM(const VkDataGraphPipelineIdentifierCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.identifierSize, settings, "uint32_t", "identifierSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pIdentifier, object.identifierSize, settings, "const uint8_t*", "pIdentifier", "const uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint8_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineDispatchInfoARM(const VkDataGraphPipelineDispatchInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelineDispatchFlagsARM<Format>(object.flags, settings, "VkDataGraphPipelineDispatchFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDataGraphProcessingEngineARM(const VkPhysicalDeviceDataGraphProcessingEngineARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkPhysicalDeviceDataGraphProcessingEngineTypeARM<Format>(object.type, settings, "VkPhysicalDeviceDataGraphProcessingEngineTypeARM", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.isForeign, settings, "VkBool32", "isForeign", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDataGraphOperationSupportARM(const VkPhysicalDeviceDataGraphOperationSupportARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkPhysicalDeviceDataGraphOperationTypeARM<Format>(object.operationType, settings, "VkPhysicalDeviceDataGraphOperationTypeARM", "operationType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.name, settings, "char[VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.version, settings, "uint32_t", "version", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyDataGraphPropertiesARM(const VkQueueFamilyDataGraphPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceDataGraphProcessingEngineARM<Format>(object.engine, settings, "VkPhysicalDeviceDataGraphProcessingEngineARM", "engine", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceDataGraphOperationSupportARM<Format>(object.operation, settings, "VkPhysicalDeviceDataGraphOperationSupportARM", "operation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphProcessingEngineCreateInfoARM(const VkDataGraphProcessingEngineCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.processingEngineCount, settings, "uint32_t", "processingEngineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pProcessingEngines, object.processingEngineCount, settings, "VkPhysicalDeviceDataGraphProcessingEngineARM*", "pProcessingEngines", "VkPhysicalDeviceDataGraphProcessingEngineARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceDataGraphProcessingEngineARM<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM(const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPhysicalDeviceDataGraphProcessingEngineTypeARM<Format>(object.engineType, settings, "VkPhysicalDeviceDataGraphProcessingEngineTypeARM", "engineType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyDataGraphProcessingEnginePropertiesARM(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalSemaphoreHandleTypeFlags<Format>(object.foreignSemaphoreHandleTypes, settings, "VkExternalSemaphoreHandleTypeFlags", "foreignSemaphoreHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlags<Format>(object.foreignMemoryHandleTypes, settings, "VkExternalMemoryHandleTypeFlags", "foreignMemoryHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM(const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.dimension, settings, "uint32_t", "dimension", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.zeroCount, settings, "uint32_t", "zeroCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.groupSize, settings, "uint32_t", "groupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphTOSANameQualityARM(const VkDataGraphTOSANameQualityARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_char<Format>(object.name, settings, "char[VK_MAX_DATA_GRAPH_TOSA_NAME_SIZE_ARM]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphTOSAQualityFlagsARM<Format>(object.qualityFlags, settings, "VkDataGraphTOSAQualityFlagsARM", "qualityFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyDataGraphTOSAPropertiesARM(const VkQueueFamilyDataGraphTOSAPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.profileCount, settings, "uint32_t", "profileCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pProfiles, object.profileCount, settings, "const VkDataGraphTOSANameQualityARM*", "pProfiles", "const VkDataGraphTOSANameQualityARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDataGraphTOSANameQualityARM<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.extensionCount, settings, "uint32_t", "extensionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pExtensions, object.extensionCount, settings, "const VkDataGraphTOSANameQualityARM*", "pExtensions", "const VkDataGraphTOSANameQualityARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDataGraphTOSANameQualityARM<Format>);
    dump_separate_members<Format>(settings);
    dump_VkDataGraphTOSALevelARM<Format>(object.level, settings, "VkDataGraphTOSALevelARM", "level", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiviewPerViewRenderAreas, settings, "VkBool32", "multiviewPerViewRenderAreas", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.perViewRenderAreaCount, settings, "uint32_t", "perViewRenderAreaCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPerViewRenderAreas, object.perViewRenderAreaCount, settings, "const VkRect2D*", "pPerViewRenderAreas", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(const VkPhysicalDevicePerStageDescriptorSetFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.perStageDescriptorSet, settings, "VkBool32", "perStageDescriptorSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dynamicPipelineLayout, settings, "VkBool32", "dynamicPipelineLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageProcessing2FeaturesQCOM(const VkPhysicalDeviceImageProcessing2FeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.textureBlockMatch2, settings, "VkBool32", "textureBlockMatch2", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageProcessing2PropertiesQCOM(const VkPhysicalDeviceImageProcessing2PropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.maxBlockMatchWindow, settings, "VkExtent2D", "maxBlockMatchWindow", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerBlockMatchWindowCreateInfoQCOM(const VkSamplerBlockMatchWindowCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.windowExtent, settings, "VkExtent2D", "windowExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBlockMatchWindowCompareModeQCOM<Format>(object.windowCompareMode, settings, "VkBlockMatchWindowCompareModeQCOM", "windowCompareMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCubicWeightsFeaturesQCOM(const VkPhysicalDeviceCubicWeightsFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.selectableCubicWeights, settings, "VkBool32", "selectableCubicWeights", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerCubicWeightsCreateInfoQCOM(const VkSamplerCubicWeightsCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCubicFilterWeightsQCOM<Format>(object.cubicWeights, settings, "VkCubicFilterWeightsQCOM", "cubicWeights", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBlitImageCubicWeightsInfoQCOM(const VkBlitImageCubicWeightsInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCubicFilterWeightsQCOM<Format>(object.cubicWeights, settings, "VkCubicFilterWeightsQCOM", "cubicWeights", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.ycbcrDegamma, settings, "VkBool32", "ycbcrDegamma", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.enableYDegamma, settings, "VkBool32", "enableYDegamma", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.enableCbCrDegamma, settings, "VkBool32", "enableCbCrDegamma", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCubicClampFeaturesQCOM(const VkPhysicalDeviceCubicClampFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cubicRangeClamp, settings, "VkBool32", "cubicRangeClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.attachmentFeedbackLoopDynamicState, settings, "VkBool32", "attachmentFeedbackLoopDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
template <ApiDumpFormat Format>
void dump_VkScreenBufferPropertiesQNX(const VkScreenBufferPropertiesQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.allocationSize, settings, "VkDeviceSize", "allocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkScreenBufferFormatPropertiesQNX(const VkScreenBufferFormatPropertiesQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.screenUsage, settings, "uint64_t", "screenUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags<Format>(object.formatFeatures, settings, "VkFormatFeatureFlags", "formatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentMapping<Format>(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrModelConversion<Format>(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSamplerYcbcrRange<Format>(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkChromaLocation<Format>(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImportScreenBufferInfoQNX(const VkImportScreenBufferInfoQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, struct _screen_buffer*>(object.buffer, settings, "struct _screen_buffer*", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalFormatQNX(const VkExternalFormatQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.screenBufferImport, settings, "VkBool32", "screenBufferImport", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_SCREEN_QNX
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceLayeredDriverPropertiesMSFT(const VkPhysicalDeviceLayeredDriverPropertiesMSFT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkLayeredDriverUnderlyingApiMSFT<Format>(object.underlyingAPI, settings, "VkLayeredDriverUnderlyingApiMSFT", "underlyingAPI", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorPoolOverallocation, settings, "VkBool32", "descriptorPoolOverallocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileMemoryHeap, settings, "VkBool32", "tileMemoryHeap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.queueSubmitBoundary, settings, "VkBool32", "queueSubmitBoundary", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.tileBufferTransfers, settings, "VkBool32", "tileBufferTransfers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTileMemoryRequirementsQCOM(const VkTileMemoryRequirementsQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.alignment, settings, "VkDeviceSize", "alignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTileMemoryBindInfoQCOM(const VkTileMemoryBindInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTileMemorySizeInfoQCOM(const VkTileMemorySizeInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDecompressMemoryRegionEXT(const VkDecompressMemoryRegionEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.srcAddress, settings, "VkDeviceAddress", "srcAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.dstAddress, settings, "VkDeviceAddress", "dstAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.compressedSize, settings, "VkDeviceSize", "compressedSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.decompressedSize, settings, "VkDeviceSize", "decompressedSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDecompressMemoryInfoEXT(const VkDecompressMemoryInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkMemoryDecompressionMethodFlagsEXT<Format>(object.decompressionMethod, settings, "VkMemoryDecompressionMethodFlagsEXT", "decompressionMethod", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pRegions, object.regionCount, settings, "const VkDecompressMemoryRegionEXT*", "pRegions", "const VkDecompressMemoryRegionEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDecompressMemoryRegionEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplaySurfaceStereoCreateInfoNV(const VkDisplaySurfaceStereoCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDisplaySurfaceStereoTypeNV<Format>(object.stereoType, settings, "VkDisplaySurfaceStereoTypeNV", "stereoType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDisplayModeStereoPropertiesNV(const VkDisplayModeStereoPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hdmi3DSupported, settings, "VkBool32", "hdmi3DSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRawAccessChainsFeaturesNV(const VkPhysicalDeviceRawAccessChainsFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderRawAccessChains, settings, "VkBool32", "shaderRawAccessChains", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalComputeQueueDeviceCreateInfoNV(const VkExternalComputeQueueDeviceCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reservedExternalQueues, settings, "uint32_t", "reservedExternalQueues", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalComputeQueueCreateInfoNV(const VkExternalComputeQueueCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkQueue<Format>(object.preferredQueue, settings, "VkQueue", "preferredQueue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkExternalComputeQueueDataParamsNV(const VkExternalComputeQueueDataParamsNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.deviceIndex, settings, "uint32_t", "deviceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceExternalComputeQueuePropertiesNV(const VkPhysicalDeviceExternalComputeQueuePropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.externalDataSize, settings, "uint32_t", "externalDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxExternalQueues, settings, "uint32_t", "maxExternalQueues", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.commandBufferInheritance, settings, "VkBool32", "commandBufferInheritance", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFloat16VectorAtomics, settings, "VkBool32", "shaderFloat16VectorAtomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderReplicatedComposites, settings, "VkBool32", "shaderReplicatedComposites", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorRollingBackingCreateInfoARM(const VkTensorRollingBackingCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.wraps, VK_MAX_TENSOR_CREATE_INFO_ROLLING_BACKING_WRAP_COUNT_ARM, settings, "uint32_t[VK_MAX_TENSOR_CREATE_INFO_ROLLING_BACKING_WRAP_COUNT_ARM]", "wraps", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTensorExplicitTilingFormatPropertiesARM(const VkTensorExplicitTilingFormatPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.brick16TilingTensorFeatures, settings, "VkFormatFeatureFlags2", "brick16TilingTensorFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.brick8TilingTensorFeatures, settings, "VkFormatFeatureFlags2", "brick8TilingTensorFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.brick4TilingTensorFeatures, settings, "VkFormatFeatureFlags2", "brick4TilingTensorFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.blockUTilingTensorFeatures, settings, "VkFormatFeatureFlags2", "blockUTilingTensorFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormatFeatureFlags2<Format>(object.blockU64kTilingTensorFeatures, settings, "VkFormatFeatureFlags2", "blockU64kTilingTensorFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderFloat8FeaturesEXT(const VkPhysicalDeviceShaderFloat8FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFloat8, settings, "VkBool32", "shaderFloat8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFloat8CooperativeMatrix, settings, "VkBool32", "shaderFloat8CooperativeMatrix", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingValidationFeaturesNV(const VkPhysicalDeviceRayTracingValidationFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingValidation, settings, "VkBool32", "rayTracingValidation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.clusterAccelerationStructure, settings, "VkBool32", "clusterAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVerticesPerCluster, settings, "uint32_t", "maxVerticesPerCluster", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTrianglesPerCluster, settings, "uint32_t", "maxTrianglesPerCluster", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.clusterScratchByteAlignment, settings, "uint32_t", "clusterScratchByteAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.clusterByteAlignment, settings, "uint32_t", "clusterByteAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.clusterTemplateByteAlignment, settings, "uint32_t", "clusterTemplateByteAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.clusterBottomLevelByteAlignment, settings, "uint32_t", "clusterBottomLevelByteAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.clusterTemplateBoundsByteAlignment, settings, "uint32_t", "clusterTemplateBoundsByteAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxClusterGeometryIndex, settings, "uint32_t", "maxClusterGeometryIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureClustersBottomLevelInputNV(const VkClusterAccelerationStructureClustersBottomLevelInputNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTotalClusterCount, settings, "uint32_t", "maxTotalClusterCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxClusterCountPerAccelerationStructure, settings, "uint32_t", "maxClusterCountPerAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureTriangleClusterInputNV(const VkClusterAccelerationStructureTriangleClusterInputNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGeometryIndexValue, settings, "uint32_t", "maxGeometryIndexValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxClusterUniqueGeometryCount, settings, "uint32_t", "maxClusterUniqueGeometryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxClusterTriangleCount, settings, "uint32_t", "maxClusterTriangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxClusterVertexCount, settings, "uint32_t", "maxClusterVertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTotalTriangleCount, settings, "uint32_t", "maxTotalTriangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTotalVertexCount, settings, "uint32_t", "maxTotalVertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minPositionTruncateBitCount, settings, "uint32_t", "minPositionTruncateBitCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureMoveObjectsInputNV(const VkClusterAccelerationStructureMoveObjectsInputNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClusterAccelerationStructureTypeNV<Format>(object.type, settings, "VkClusterAccelerationStructureTypeNV", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.noMoveOverlap, settings, "VkBool32", "noMoveOverlap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.maxMovedBytes, settings, "VkDeviceSize", "maxMovedBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureOpInputNV(const VkClusterAccelerationStructureOpInputNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    dump_pointer<Format>(object.pClustersBottomLevel, settings, "VkClusterAccelerationStructureClustersBottomLevelInputNV*", "pClustersBottomLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkClusterAccelerationStructureClustersBottomLevelInputNV<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pTriangleClusters, settings, "VkClusterAccelerationStructureTriangleClusterInputNV*", "pTriangleClusters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkClusterAccelerationStructureTriangleClusterInputNV<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pMoveObjects, settings, "VkClusterAccelerationStructureMoveObjectsInputNV*", "pMoveObjects", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkClusterAccelerationStructureMoveObjectsInputNV<Format>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureInputInfoNV(const VkClusterAccelerationStructureInputInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxAccelerationStructureCount, settings, "uint32_t", "maxAccelerationStructureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuildAccelerationStructureFlagsKHR<Format>(object.flags, settings, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClusterAccelerationStructureOpTypeNV<Format>(object.opType, settings, "VkClusterAccelerationStructureOpTypeNV", "opType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClusterAccelerationStructureOpModeNV<Format>(object.opMode, settings, "VkClusterAccelerationStructureOpModeNV", "opMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClusterAccelerationStructureOpInputNV<Format>(object.opInput, settings, "VkClusterAccelerationStructureOpInputNV", "opInput", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkStridedDeviceAddressRegionKHR(const VkStridedDeviceAddressRegionKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.stride, settings, "VkDeviceSize", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureCommandsInfoNV(const VkClusterAccelerationStructureCommandsInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClusterAccelerationStructureInputInfoNV<Format>(object.input, settings, "VkClusterAccelerationStructureInputInfoNV", "input", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.dstImplicitData, settings, "VkDeviceAddress", "dstImplicitData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.scratchData, settings, "VkDeviceAddress", "scratchData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStridedDeviceAddressRegionKHR<Format>(object.dstAddressesArray, settings, "VkStridedDeviceAddressRegionKHR", "dstAddressesArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStridedDeviceAddressRegionKHR<Format>(object.dstSizesArray, settings, "VkStridedDeviceAddressRegionKHR", "dstSizesArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStridedDeviceAddressRegionKHR<Format>(object.srcInfosArray, settings, "VkStridedDeviceAddressRegionKHR", "srcInfosArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.srcInfosCount, settings, "VkDeviceAddress", "srcInfosCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClusterAccelerationStructureAddressResolutionFlagsNV<Format>(object.addressResolutionFlags, settings, "VkClusterAccelerationStructureAddressResolutionFlagsNV", "addressResolutionFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkStridedDeviceAddressNV(const VkStridedDeviceAddressNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.startAddress, settings, "VkDeviceAddress", "startAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.strideInBytes, settings, "VkDeviceSize", "strideInBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV(const VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.geometryIndex, settings, "uint32_t:24", "geometryIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t:5", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.geometryFlags, settings, "uint32_t:3", "geometryFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureMoveObjectsInfoNV(const VkClusterAccelerationStructureMoveObjectsInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.srcAccelerationStructure, settings, "VkDeviceAddress", "srcAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV(const VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.clusterReferencesCount, settings, "uint32_t", "clusterReferencesCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.clusterReferencesStride, settings, "uint32_t", "clusterReferencesStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.clusterReferences, settings, "VkDeviceAddress", "clusterReferences", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureBuildTriangleClusterInfoNV(const VkClusterAccelerationStructureBuildTriangleClusterInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.clusterID, settings, "uint32_t", "clusterID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClusterAccelerationStructureClusterFlagsNV<Format>(object.clusterFlags, settings, "VkClusterAccelerationStructureClusterFlagsNV", "clusterFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.triangleCount, settings, "uint32_t:9", "triangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vertexCount, settings, "uint32_t:9", "vertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.positionTruncateBitCount, settings, "uint32_t:6", "positionTruncateBitCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.indexType, settings, "uint32_t:4", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.opacityMicromapIndexType, settings, "uint32_t:4", "opacityMicromapIndexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV<Format>(object.baseGeometryIndexAndGeometryFlags, settings, "VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV", "baseGeometryIndexAndGeometryFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.indexBufferStride, settings, "uint16_t", "indexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.vertexBufferStride, settings, "uint16_t", "vertexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.geometryIndexAndFlagsBufferStride, settings, "uint16_t", "geometryIndexAndFlagsBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.opacityMicromapIndexBufferStride, settings, "uint16_t", "opacityMicromapIndexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.indexBuffer, settings, "VkDeviceAddress", "indexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.vertexBuffer, settings, "VkDeviceAddress", "vertexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.geometryIndexAndFlagsBuffer, settings, "VkDeviceAddress", "geometryIndexAndFlagsBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.opacityMicromapArray, settings, "VkDeviceAddress", "opacityMicromapArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.opacityMicromapIndexBuffer, settings, "VkDeviceAddress", "opacityMicromapIndexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV(const VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.clusterID, settings, "uint32_t", "clusterID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClusterAccelerationStructureClusterFlagsNV<Format>(object.clusterFlags, settings, "VkClusterAccelerationStructureClusterFlagsNV", "clusterFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.triangleCount, settings, "uint32_t:9", "triangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.vertexCount, settings, "uint32_t:9", "vertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.positionTruncateBitCount, settings, "uint32_t:6", "positionTruncateBitCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.indexType, settings, "uint32_t:4", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.opacityMicromapIndexType, settings, "uint32_t:4", "opacityMicromapIndexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV<Format>(object.baseGeometryIndexAndGeometryFlags, settings, "VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV", "baseGeometryIndexAndGeometryFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.indexBufferStride, settings, "uint16_t", "indexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.vertexBufferStride, settings, "uint16_t", "vertexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.geometryIndexAndFlagsBufferStride, settings, "uint16_t", "geometryIndexAndFlagsBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint16_t>(object.opacityMicromapIndexBufferStride, settings, "uint16_t", "opacityMicromapIndexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.indexBuffer, settings, "VkDeviceAddress", "indexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.vertexBuffer, settings, "VkDeviceAddress", "vertexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.geometryIndexAndFlagsBuffer, settings, "VkDeviceAddress", "geometryIndexAndFlagsBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.opacityMicromapArray, settings, "VkDeviceAddress", "opacityMicromapArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.opacityMicromapIndexBuffer, settings, "VkDeviceAddress", "opacityMicromapIndexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.instantiationBoundingBoxLimit, settings, "VkDeviceAddress", "instantiationBoundingBoxLimit", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureInstantiateClusterInfoNV(const VkClusterAccelerationStructureInstantiateClusterInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.clusterIdOffset, settings, "uint32_t", "clusterIdOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.geometryIndexOffset, settings, "uint32_t:24", "geometryIndexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.reserved, settings, "uint32_t:8", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.clusterTemplateAddress, settings, "VkDeviceAddress", "clusterTemplateAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStridedDeviceAddressNV<Format>(object.vertexBuffer, settings, "VkStridedDeviceAddressNV", "vertexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkClusterAccelerationStructureGetTemplateIndicesInfoNV(const VkClusterAccelerationStructureGetTemplateIndicesInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.clusterTemplateAddress, settings, "VkDeviceAddress", "clusterTemplateAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureBuildSizesInfoKHR(const VkAccelerationStructureBuildSizesInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.accelerationStructureSize, settings, "VkDeviceSize", "accelerationStructureSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.updateScratchSize, settings, "VkDeviceSize", "updateScratchSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.buildScratchSize, settings, "VkDeviceSize", "buildScratchSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.allowClusterAccelerationStructure, settings, "VkBool32", "allowClusterAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.partitionedAccelerationStructure, settings, "VkBool32", "partitionedAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPartitionCount, settings, "uint32_t", "maxPartitionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPartitionedAccelerationStructureFlagsNV(const VkPartitionedAccelerationStructureFlagsNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.enablePartitionTranslation, settings, "VkBool32", "enablePartitionTranslation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBuildPartitionedAccelerationStructureIndirectCommandNV(const VkBuildPartitionedAccelerationStructureIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkPartitionedAccelerationStructureOpTypeNV<Format>(object.opType, settings, "VkPartitionedAccelerationStructureOpTypeNV", "opType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.argCount, settings, "uint32_t", "argCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkStridedDeviceAddressNV<Format>(object.argData, settings, "VkStridedDeviceAddressNV", "argData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPartitionedAccelerationStructureWriteInstanceDataNV(const VkPartitionedAccelerationStructureWriteInstanceDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkTransformMatrixKHR<Format>(object.transform, settings, "VkTransformMatrixKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.explicitAABB, 6, settings, "float[6]", "explicitAABB", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, float>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceID, settings, "uint32_t", "instanceID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceMask, settings, "uint32_t", "instanceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceContributionToHitGroupIndex, settings, "uint32_t", "instanceContributionToHitGroupIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPartitionedAccelerationStructureInstanceFlagsNV<Format>(object.instanceFlags, settings, "VkPartitionedAccelerationStructureInstanceFlagsNV", "instanceFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceIndex, settings, "uint32_t", "instanceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.partitionIndex, settings, "uint32_t", "partitionIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.accelerationStructure, settings, "VkDeviceAddress", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPartitionedAccelerationStructureUpdateInstanceDataNV(const VkPartitionedAccelerationStructureUpdateInstanceDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.instanceIndex, settings, "uint32_t", "instanceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceContributionToHitGroupIndex, settings, "uint32_t", "instanceContributionToHitGroupIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.accelerationStructure, settings, "VkDeviceAddress", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPartitionedAccelerationStructureWritePartitionTranslationDataNV(const VkPartitionedAccelerationStructureWritePartitionTranslationDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.partitionIndex, settings, "uint32_t", "partitionIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.partitionTranslation, 3, settings, "float[3]", "partitionTranslation", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, float>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkWriteDescriptorSetPartitionedAccelerationStructureNV(const VkWriteDescriptorSetPartitionedAccelerationStructureNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAccelerationStructures, object.accelerationStructureCount, settings, "const VkDeviceAddress*", "pAccelerationStructures", "const VkDeviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const VkDeviceAddress>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPartitionedAccelerationStructureInstancesInputNV(const VkPartitionedAccelerationStructureInstancesInputNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuildAccelerationStructureFlagsKHR<Format>(object.flags, settings, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.instanceCount, settings, "uint32_t", "instanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxInstancePerPartitionCount, settings, "uint32_t", "maxInstancePerPartitionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.partitionCount, settings, "uint32_t", "partitionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxInstanceInGlobalPartitionCount, settings, "uint32_t", "maxInstanceInGlobalPartitionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBuildPartitionedAccelerationStructureInfoNV(const VkBuildPartitionedAccelerationStructureInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPartitionedAccelerationStructureInstancesInputNV<Format>(object.input, settings, "VkPartitionedAccelerationStructureInstancesInputNV", "input", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.srcAccelerationStructureData, settings, "VkDeviceAddress", "srcAccelerationStructureData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.dstAccelerationStructureData, settings, "VkDeviceAddress", "dstAccelerationStructureData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.scratchData, settings, "VkDeviceAddress", "scratchData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.srcInfos, settings, "VkDeviceAddress", "srcInfos", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.srcInfosCount, settings, "VkDeviceAddress", "srcInfosCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceGeneratedCommands, settings, "VkBool32", "deviceGeneratedCommands", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dynamicGeneratedPipelineLayout, settings, "VkBool32", "dynamicGeneratedPipelineLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIndirectPipelineCount, settings, "uint32_t", "maxIndirectPipelineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIndirectShaderObjectCount, settings, "uint32_t", "maxIndirectShaderObjectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIndirectSequenceCount, settings, "uint32_t", "maxIndirectSequenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIndirectCommandsTokenCount, settings, "uint32_t", "maxIndirectCommandsTokenCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIndirectCommandsTokenOffset, settings, "uint32_t", "maxIndirectCommandsTokenOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxIndirectCommandsIndirectStride, settings, "uint32_t", "maxIndirectCommandsIndirectStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectCommandsInputModeFlagsEXT<Format>(object.supportedIndirectCommandsInputModes, settings, "VkIndirectCommandsInputModeFlagsEXT", "supportedIndirectCommandsInputModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.supportedIndirectCommandsShaderStages, settings, "VkShaderStageFlags", "supportedIndirectCommandsShaderStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.supportedIndirectCommandsShaderStagesPipelineBinding, settings, "VkShaderStageFlags", "supportedIndirectCommandsShaderStagesPipelineBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.supportedIndirectCommandsShaderStagesShaderBinding, settings, "VkShaderStageFlags", "supportedIndirectCommandsShaderStagesShaderBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceGeneratedCommandsTransformFeedback, settings, "VkBool32", "deviceGeneratedCommandsTransformFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.deviceGeneratedCommandsMultiDrawIndirectCount, settings, "VkBool32", "deviceGeneratedCommandsMultiDrawIndirectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeneratedCommandsMemoryRequirementsInfoEXT(const VkGeneratedCommandsMemoryRequirementsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectExecutionSetEXT<Format>(object.indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectCommandsLayoutEXT<Format>(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSequenceCount, settings, "uint32_t", "maxSequenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDrawCount, settings, "uint32_t", "maxDrawCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectExecutionSetPipelineInfoEXT(const VkIndirectExecutionSetPipelineInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.initialPipeline, settings, "VkPipeline", "initialPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPipelineCount, settings, "uint32_t", "maxPipelineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectExecutionSetShaderLayoutInfoEXT(const VkIndirectExecutionSetShaderLayoutInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.setLayoutCount, settings, "uint32_t", "setLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSetLayouts, object.setLayoutCount, settings, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectExecutionSetShaderInfoEXT(const VkIndirectExecutionSetShaderInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderCount, settings, "uint32_t", "shaderCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pInitialShaders, object.shaderCount, settings, "const VkShaderEXT*", "pInitialShaders", "const VkShaderEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkShaderEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pSetLayoutInfos, object.shaderCount, settings, "const VkIndirectExecutionSetShaderLayoutInfoEXT*", "pSetLayoutInfos", "const VkIndirectExecutionSetShaderLayoutInfoEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectExecutionSetShaderLayoutInfoEXT<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxShaderCount, settings, "uint32_t", "maxShaderCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.pushConstantRangeCount, settings, "uint32_t", "pushConstantRangeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pPushConstantRanges, object.pushConstantRangeCount, settings, "const VkPushConstantRange*", "pPushConstantRanges", "const VkPushConstantRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPushConstantRange<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectExecutionSetInfoEXT(const VkIndirectExecutionSetInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    if (ApiDumpInstance::current().getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT) {
        dump_pointer<Format>(object.pPipelineInfo, settings, "const VkIndirectExecutionSetPipelineInfoEXT*", "pPipelineInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectExecutionSetPipelineInfoEXT<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT) {
        dump_pointer<Format>(object.pShaderInfo, settings, "const VkIndirectExecutionSetShaderInfoEXT*", "pShaderInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectExecutionSetShaderInfoEXT<Format>);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectExecutionSetCreateInfoEXT(const VkIndirectExecutionSetCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    ApiDumpInstance::current().setIndirectExecutionSetInfoType(object.type);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectExecutionSetInfoTypeEXT<Format>(object.type, settings, "VkIndirectExecutionSetInfoTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectExecutionSetInfoEXT<Format>(object.info, settings, "VkIndirectExecutionSetInfoEXT", "info", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeneratedCommandsInfoEXT(const VkGeneratedCommandsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.shaderStages, settings, "VkShaderStageFlags", "shaderStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectExecutionSetEXT<Format>(object.indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectCommandsLayoutEXT<Format>(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.indirectAddress, settings, "VkDeviceAddress", "indirectAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.indirectAddressSize, settings, "VkDeviceSize", "indirectAddressSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.preprocessAddress, settings, "VkDeviceAddress", "preprocessAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.preprocessSize, settings, "VkDeviceSize", "preprocessSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxSequenceCount, settings, "uint32_t", "maxSequenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.sequenceCountAddress, settings, "VkDeviceAddress", "sequenceCountAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDrawCount, settings, "uint32_t", "maxDrawCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkWriteIndirectExecutionSetPipelineEXT(const VkWriteIndirectExecutionSetPipelineEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsPushConstantTokenEXT(const VkIndirectCommandsPushConstantTokenEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkPushConstantRange<Format>(object.updateRange, settings, "VkPushConstantRange", "updateRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsVertexBufferTokenEXT(const VkIndirectCommandsVertexBufferTokenEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.vertexBindingUnit, settings, "uint32_t", "vertexBindingUnit", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsIndexBufferTokenEXT(const VkIndirectCommandsIndexBufferTokenEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkIndirectCommandsInputModeFlagBitsEXT<Format>(object.mode, settings, "VkIndirectCommandsInputModeFlagBitsEXT", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsExecutionSetTokenEXT(const VkIndirectCommandsExecutionSetTokenEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkIndirectExecutionSetInfoTypeEXT<Format>(object.type, settings, "VkIndirectExecutionSetInfoTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.shaderStages, settings, "VkShaderStageFlags", "shaderStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsTokenDataEXT(const VkIndirectCommandsTokenDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    if (ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT || ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT) {
        dump_pointer<Format>(object.pPushConstant, settings, "const VkIndirectCommandsPushConstantTokenEXT*", "pPushConstant", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsPushConstantTokenEXT<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT) {
        dump_pointer<Format>(object.pVertexBuffer, settings, "const VkIndirectCommandsVertexBufferTokenEXT*", "pVertexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsVertexBufferTokenEXT<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT) {
        dump_pointer<Format>(object.pIndexBuffer, settings, "const VkIndirectCommandsIndexBufferTokenEXT*", "pIndexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsIndexBufferTokenEXT<Format>);
    }
    dump_separate_members<Format>(settings);
    if (ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT) {
        dump_pointer<Format>(object.pExecutionSet, settings, "const VkIndirectCommandsExecutionSetTokenEXT*", "pExecutionSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsExecutionSetTokenEXT<Format>);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsLayoutTokenEXT(const VkIndirectCommandsLayoutTokenEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    ApiDumpInstance::current().setIndirectCommandsLayoutToken(object.type);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectCommandsTokenTypeEXT<Format>(object.type, settings, "VkIndirectCommandsTokenTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectCommandsTokenDataEXT<Format>(object.data, settings, "VkIndirectCommandsTokenDataEXT", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkIndirectCommandsLayoutCreateInfoEXT(const VkIndirectCommandsLayoutCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndirectCommandsLayoutUsageFlagsEXT<Format>(object.flags, settings, "VkIndirectCommandsLayoutUsageFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.shaderStages, settings, "VkShaderStageFlags", "shaderStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.indirectStride, settings, "uint32_t", "indirectStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.pipelineLayout, settings, "VkPipelineLayout", "pipelineLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.tokenCount, settings, "uint32_t", "tokenCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pTokens, object.tokenCount, settings, "const VkIndirectCommandsLayoutTokenEXT*", "pTokens", "const VkIndirectCommandsLayoutTokenEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsLayoutTokenEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDrawIndirectCountIndirectCommandEXT(const VkDrawIndirectCountIndirectCommandEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.commandCount, settings, "uint32_t", "commandCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindVertexBufferIndirectCommandEXT(const VkBindVertexBufferIndirectCommandEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBindIndexBufferIndirectCommandEXT(const VkBindIndexBufferIndirectCommandEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type_hex<Format, VkDeviceAddress>(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndexType<Format>(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeneratedCommandsPipelineInfoEXT(const VkGeneratedCommandsPipelineInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkGeneratedCommandsShaderInfoEXT(const VkGeneratedCommandsShaderInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderCount, settings, "uint32_t", "shaderCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pShaders, object.shaderCount, settings, "const VkShaderEXT*", "pShaders", "const VkShaderEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkShaderEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkWriteIndirectExecutionSetShaderEXT(const VkWriteIndirectExecutionSetShaderEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderEXT<Format>(object.shader, settings, "VkShaderEXT", "shader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(const VkPhysicalDeviceImageAlignmentControlFeaturesMESA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.imageAlignmentControl, settings, "VkBool32", "imageAlignmentControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(const VkPhysicalDeviceImageAlignmentControlPropertiesMESA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.supportedImageAlignmentMask, settings, "uint32_t", "supportedImageAlignmentMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkImageAlignmentControlCreateInfoMESA(const VkImageAlignmentControlCreateInfoMESA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maximumRequestedAlignment, settings, "uint32_t", "maximumRequestedAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPushConstantBankInfoNV(const VkPushConstantBankInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.bank, settings, "uint32_t", "bank", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePushConstantBankFeaturesNV(const VkPhysicalDevicePushConstantBankFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pushConstantBank, settings, "VkBool32", "pushConstantBank", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePushConstantBankPropertiesNV(const VkPhysicalDevicePushConstantBankPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGraphicsPushConstantBanks, settings, "uint32_t", "maxGraphicsPushConstantBanks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxComputePushConstantBanks, settings, "uint32_t", "maxComputePushConstantBanks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxGraphicsPushDataBanks, settings, "uint32_t", "maxGraphicsPushDataBanks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxComputePushDataBanks, settings, "uint32_t", "maxComputePushDataBanks", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRayTracingInvocationReorderModeEXT<Format>(object.rayTracingInvocationReorderReorderingHint, settings, "VkRayTracingInvocationReorderModeEXT", "rayTracingInvocationReorderReorderingHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxShaderBindingTableRecordIndex, settings, "uint32_t", "maxShaderBindingTableRecordIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingInvocationReorder, settings, "VkBool32", "rayTracingInvocationReorder", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDepthClampControlFeaturesEXT(const VkPhysicalDeviceDepthClampControlFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.depthClampControl, settings, "VkBool32", "depthClampControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineViewportDepthClampControlCreateInfoEXT(const VkPipelineViewportDepthClampControlCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDepthClampModeEXT<Format>(object.depthClampMode, settings, "VkDepthClampModeEXT", "depthClampMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDepthClampRange, settings, "const VkDepthClampRangeEXT*", "pDepthClampRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDepthClampRangeEXT<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_OHOS)
template <ApiDumpFormat Format>
void dump_VkSurfaceCreateInfoOHOS(const VkSurfaceCreateInfoOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSurfaceCreateFlagsOHOS<Format>(object.flags, settings, "VkSurfaceCreateFlagsOHOS", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, OHNativeWindow*>(object.window, settings, "OHNativeWindow*", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_OHOS
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceHdrVividFeaturesHUAWEI(const VkPhysicalDeviceHdrVividFeaturesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hdrVivid, settings, "VkBool32", "hdrVivid", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkHdrVividDynamicMetadataHUAWEI(const VkHdrVividDynamicMetadataHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, size_t>(object.dynamicMetadataSize, settings, "size_t", "dynamicMetadataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pDynamicMetadata, settings, "const void*", "pDynamicMetadata", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCooperativeMatrixFlexibleDimensionsPropertiesNV(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.MGranularity, settings, "uint32_t", "MGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.NGranularity, settings, "uint32_t", "NGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.KGranularity, settings, "uint32_t", "KGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.AType, settings, "VkComponentTypeKHR", "AType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.BType, settings, "VkComponentTypeKHR", "BType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.CType, settings, "VkComponentTypeKHR", "CType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkComponentTypeKHR<Format>(object.ResultType, settings, "VkComponentTypeKHR", "ResultType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.saturatingAccumulation, settings, "VkBool32", "saturatingAccumulation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkScopeKHR<Format>(object.scope, settings, "VkScopeKHR", "scope", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.workgroupInvocations, settings, "uint32_t", "workgroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(const VkPhysicalDeviceCooperativeMatrix2FeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrixWorkgroupScope, settings, "VkBool32", "cooperativeMatrixWorkgroupScope", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrixFlexibleDimensions, settings, "VkBool32", "cooperativeMatrixFlexibleDimensions", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrixReductions, settings, "VkBool32", "cooperativeMatrixReductions", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrixConversions, settings, "VkBool32", "cooperativeMatrixConversions", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrixPerElementOperations, settings, "VkBool32", "cooperativeMatrixPerElementOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrixTensorAddressing, settings, "VkBool32", "cooperativeMatrixTensorAddressing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrixBlockLoads, settings, "VkBool32", "cooperativeMatrixBlockLoads", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(const VkPhysicalDeviceCooperativeMatrix2PropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize, settings, "uint32_t", "cooperativeMatrixWorkgroupScopeMaxWorkgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cooperativeMatrixFlexibleDimensionsMaxDimension, settings, "uint32_t", "cooperativeMatrixFlexibleDimensionsMaxDimension", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cooperativeMatrixWorkgroupScopeReservedSharedMemory, settings, "uint32_t", "cooperativeMatrixWorkgroupScopeReservedSharedMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineOpacityMicromap, settings, "VkBool32", "pipelineOpacityMicromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_METAL_EXT)
template <ApiDumpFormat Format>
void dump_VkImportMemoryMetalHandleInfoEXT(const VkImportMemoryMetalHandleInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, void*>(object.handle, settings, "void*", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryMetalHandlePropertiesEXT(const VkMemoryMetalHandlePropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkMemoryGetMetalHandleInfoEXT(const VkMemoryGetMetalHandleInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceMemory<Format>(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExternalMemoryHandleTypeFlagBits<Format>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_METAL_EXT
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePerformanceCountersByRegionFeaturesARM(const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.performanceCountersByRegion, settings, "VkBool32", "performanceCountersByRegion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePerformanceCountersByRegionPropertiesARM(const VkPhysicalDevicePerformanceCountersByRegionPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerRegionPerformanceCounters, settings, "uint32_t", "maxPerRegionPerformanceCounters", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkExtent2D<Format>(object.performanceCounterRegionSize, settings, "VkExtent2D", "performanceCounterRegionSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.rowStrideAlignment, settings, "uint32_t", "rowStrideAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.regionAlignment, settings, "uint32_t", "regionAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.identityTransformOrder, settings, "VkBool32", "identityTransformOrder", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceCounterARM(const VkPerformanceCounterARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.counterID, settings, "uint32_t", "counterID", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPerformanceCounterDescriptionARM(const VkPerformanceCounterDescriptionARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPerformanceCounterDescriptionFlagsARM<Format>(object.flags, settings, "VkPerformanceCounterDescriptionFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRenderPassPerformanceCountersByRegionBeginInfoARM(const VkRenderPassPerformanceCountersByRegionBeginInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.counterAddressCount, settings, "uint32_t", "counterAddressCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCounterAddresses, object.counterAddressCount, settings, "const VkDeviceAddress*", "pCounterAddresses", "const VkDeviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const VkDeviceAddress>);
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.serializeRegions, settings, "VkBool32", "serializeRegions", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.counterIndexCount, settings, "uint32_t", "counterIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pCounterIndices, object.counterIndexCount, settings, "uint32_t*", "pCounterIndices", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderInstrumentationFeaturesARM(const VkPhysicalDeviceShaderInstrumentationFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderInstrumentation, settings, "VkBool32", "shaderInstrumentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderInstrumentationPropertiesARM(const VkPhysicalDeviceShaderInstrumentationPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numMetrics, settings, "uint32_t", "numMetrics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.perBasicBlockGranularity, settings, "VkBool32", "perBasicBlockGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderInstrumentationCreateInfoARM(const VkShaderInstrumentationCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderInstrumentationMetricDescriptionARM(const VkShaderInstrumentationMetricDescriptionARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_char<Format>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkShaderInstrumentationMetricDataHeaderARM(const VkShaderInstrumentationMetricDataHeaderARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.resultIndex, settings, "uint32_t", "resultIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.resultSubIndex, settings, "uint32_t", "resultSubIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkShaderStageFlags<Format>(object.stages, settings, "VkShaderStageFlags", "stages", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.basicBlockIndex, settings, "uint32_t", "basicBlockIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.vertexAttributeRobustness, settings, "VkBool32", "vertexAttributeRobustness", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFormatPackFeaturesARM(const VkPhysicalDeviceFormatPackFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.formatPack, settings, "VkBool32", "formatPack", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE(const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.fragmentDensityMapLayered, settings, "VkBool32", "fragmentDensityMapLayered", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE(const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFragmentDensityMapLayers, settings, "uint32_t", "maxFragmentDensityMapLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineFragmentDensityMapLayeredCreateInfoVALVE(const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxFragmentDensityMapLayers, settings, "uint32_t", "maxFragmentDensityMapLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSetPresentConfigNV(const VkSetPresentConfigNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.numFramesPerBatch, settings, "uint32_t", "numFramesPerBatch", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.presentConfigFeedback, settings, "uint32_t", "presentConfigFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePresentMeteringFeaturesNV(const VkPhysicalDevicePresentMeteringFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.presentMetering, settings, "VkBool32", "presentMetering", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT(const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multisampledRenderToSwapchain, settings, "VkBool32", "multisampledRenderToSwapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkSwapchainFlagsSurfaceCapabilitiesEXT(const VkSwapchainFlagsSurfaceCapabilitiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkSwapchainCreateFlagsKHR<Format>(object.swapchainSupportedFlags, settings, "VkSwapchainCreateFlagsKHR", "swapchainSupportedFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.zeroInitializeDeviceMemory, settings, "VkBool32", "zeroInitializeDeviceMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShader64BitIndexingFeaturesEXT(const VkPhysicalDeviceShader64BitIndexingFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shader64BitIndexing, settings, "VkBool32", "shader64BitIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCustomResolveFeaturesEXT(const VkPhysicalDeviceCustomResolveFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.customResolve, settings, "VkBool32", "customResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkBeginCustomResolveInfoEXT(const VkBeginCustomResolveInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCustomResolveCreateInfoEXT(const VkCustomResolveCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.customResolve, settings, "VkBool32", "customResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pColorAttachmentFormats, object.colorAttachmentCount, settings, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat<Format>);
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.depthAttachmentFormat, settings, "VkFormat", "depthAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.stencilAttachmentFormat, settings, "VkFormat", "stencilAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPipelineCacheHeaderVersionDataGraphQCOM(const VkPipelineCacheHeaderVersionDataGraphQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.headerSize, settings, "uint32_t", "headerSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCacheHeaderVersion<Format>(object.headerVersion, settings, "VkPipelineCacheHeaderVersion", "headerVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphModelCacheTypeQCOM<Format>(object.cacheType, settings, "VkDataGraphModelCacheTypeQCOM", "cacheType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.cacheVersion, settings, "uint32_t", "cacheVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.toolchainVersion, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM, settings, "uint32_t[VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM]", "toolchainVersion", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineBuiltinModelCreateInfoQCOM(const VkDataGraphPipelineBuiltinModelCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pOperation, settings, "const VkPhysicalDeviceDataGraphOperationSupportARM*", "pOperation", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceDataGraphOperationSupportARM<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDataGraphModelFeaturesQCOM(const VkPhysicalDeviceDataGraphModelFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dataGraphModel, settings, "VkBool32", "dataGraphModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM(const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dataGraphOpticalFlow, settings, "VkBool32", "dataGraphOpticalFlow", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkQueueFamilyDataGraphOpticalFlowPropertiesARM(const VkQueueFamilyDataGraphOpticalFlowPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphOpticalFlowGridSizeFlagsARM<Format>(object.supportedOutputGridSizes, settings, "VkDataGraphOpticalFlowGridSizeFlagsARM", "supportedOutputGridSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphOpticalFlowGridSizeFlagsARM<Format>(object.supportedHintGridSizes, settings, "VkDataGraphOpticalFlowGridSizeFlagsARM", "supportedHintGridSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.hintSupported, settings, "VkBool32", "hintSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.costSupported, settings, "VkBool32", "costSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minWidth, settings, "uint32_t", "minWidth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minHeight, settings, "uint32_t", "minHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxWidth, settings, "uint32_t", "maxWidth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxHeight, settings, "uint32_t", "maxHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineOpticalFlowCreateInfoARM(const VkDataGraphPipelineOpticalFlowCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.imageFormat, settings, "VkFormat", "imageFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.flowVectorFormat, settings, "VkFormat", "flowVectorFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.costFormat, settings, "VkFormat", "costFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphOpticalFlowGridSizeFlagsARM<Format>(object.outputGridSize, settings, "VkDataGraphOpticalFlowGridSizeFlagsARM", "outputGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphOpticalFlowGridSizeFlagsARM<Format>(object.hintGridSize, settings, "VkDataGraphOpticalFlowGridSizeFlagsARM", "hintGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphOpticalFlowPerformanceLevelARM<Format>(object.performanceLevel, settings, "VkDataGraphOpticalFlowPerformanceLevelARM", "performanceLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphOpticalFlowCreateFlagsARM<Format>(object.flags, settings, "VkDataGraphOpticalFlowCreateFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphOpticalFlowImageFormatPropertiesARM(const VkDataGraphOpticalFlowImageFormatPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphOpticalFlowImageFormatInfoARM(const VkDataGraphOpticalFlowImageFormatInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphOpticalFlowImageUsageFlagsARM<Format>(object.usage, settings, "VkDataGraphOpticalFlowImageUsageFlagsARM", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineOpticalFlowDispatchInfoARM(const VkDataGraphPipelineOpticalFlowDispatchInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphOpticalFlowExecuteFlagsARM<Format>(object.flags, settings, "VkDataGraphOpticalFlowExecuteFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.meanFlowL1NormHint, settings, "uint32_t", "meanFlowL1NormHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineResourceInfoImageLayoutARM(const VkDataGraphPipelineResourceInfoImageLayoutARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkImageLayout<Format>(object.layout, settings, "VkImageLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSingleNodeConnectionARM(const VkDataGraphPipelineSingleNodeConnectionARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.set, settings, "uint32_t", "set", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelineNodeConnectionTypeARM<Format>(object.connection, settings, "VkDataGraphPipelineNodeConnectionTypeARM", "connection", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSingleNodeCreateInfoARM(const VkDataGraphPipelineSingleNodeCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDataGraphPipelineNodeTypeARM<Format>(object.nodeType, settings, "VkDataGraphPipelineNodeTypeARM", "nodeType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.connectionCount, settings, "uint32_t", "connectionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pConnections, object.connectionCount, settings, "const VkDataGraphPipelineSingleNodeConnectionARM*", "pConnections", "const VkDataGraphPipelineSingleNodeConnectionARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDataGraphPipelineSingleNodeConnectionARM<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderLongVectorFeaturesEXT(const VkPhysicalDeviceShaderLongVectorFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.longVector, settings, "VkBool32", "longVector", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderLongVectorPropertiesEXT(const VkPhysicalDeviceShaderLongVectorPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVectorComponents, settings, "uint32_t", "maxVectorComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC(const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.pipelineCacheIncrementalMode, settings, "VkBool32", "pipelineCacheIncrementalMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderUniformBufferUnsizedArray, settings, "VkBool32", "shaderUniformBufferUnsizedArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkComputeOccupancyPriorityParametersNV(const VkComputeOccupancyPriorityParametersNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.occupancyPriority, settings, "float", "occupancyPriority", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, float>(object.occupancyThrottling, settings, "float", "occupancyThrottling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV(const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.computeOccupancyPriority, settings, "VkBool32", "computeOccupancyPriority", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderSubgroupPartitioned, settings, "VkBool32", "shaderSubgroupPartitioned", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#if defined(VK_USE_PLATFORM_UBM_SEC)
template <ApiDumpFormat Format>
void dump_VkUbmSurfaceCreateInfoSEC(const VkUbmSurfaceCreateInfoSEC& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkUbmSurfaceCreateFlagsSEC<Format>(object.flags, settings, "VkUbmSurfaceCreateFlagsSEC", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, struct ubm_device*>(object.device, settings, "struct ubm_device*", "device", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, struct ubm_surface*>(object.surface, settings, "struct ubm_surface*", "surface", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
#endif  // VK_USE_PLATFORM_UBM_SEC
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT(const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFloat4, settings, "VkBool32", "shaderFloat4", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFloat6, settings, "VkBool32", "shaderFloat6", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderFloat8UnsignedE8M0, settings, "VkBool32", "shaderFloat8UnsignedE8M0", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderMXInt8, settings, "VkBool32", "shaderMXInt8", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE(const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderMixedFloatDotProductFloat16AccFloat32, settings, "VkBool32", "shaderMixedFloatDotProductFloat16AccFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderMixedFloatDotProductFloat16AccFloat16, settings, "VkBool32", "shaderMixedFloatDotProductFloat16AccFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderMixedFloatDotProductBFloat16Acc, settings, "VkBool32", "shaderMixedFloatDotProductBFloat16Acc", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.shaderMixedFloatDotProductFloat8AccFloat32, settings, "VkBool32", "shaderMixedFloatDotProductFloat8AccFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkThrottleHintSubmitInfoSEC(const VkThrottleHintSubmitInfoSEC& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkThrottleHintTypeSEC<Format>(object.throttleHint, settings, "VkThrottleHintTypeSEC", "throttleHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceThrottleHintFeaturesSEC(const VkPhysicalDeviceThrottleHintFeaturesSEC& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.throttleHint, settings, "VkBool32", "throttleHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM(const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.dataGraphNeuralAcceleratorStatistics, settings, "VkBool32", "dataGraphNeuralAcceleratorStatistics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineNeuralStatisticsCreateInfoARM(const VkDataGraphPipelineNeuralStatisticsCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.allowNeuralStatistics, settings, "VkBool32", "allowNeuralStatistics", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM(const VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkNeuralAcceleratorStatisticsModeARM<Format>(object.mode, settings, "VkNeuralAcceleratorStatisticsModeARM", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT(const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primitiveRestartIndex, settings, "VkBool32", "primitiveRestartIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV(const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.cooperativeMatrixDecodeVector, settings, "VkBool32", "cooperativeMatrixDecodeVector", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureBuildRangeInfoKHR(const VkAccelerationStructureBuildRangeInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.primitiveCount, settings, "uint32_t", "primitiveCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.primitiveOffset, settings, "uint32_t", "primitiveOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.firstVertex, settings, "uint32_t", "firstVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.transformOffset, settings, "uint32_t", "transformOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkFormat<Format>(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxVertex, settings, "uint32_t", "maxVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkIndexType<Format>(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.indexData, settings, "VkDeviceOrHostAddressConstKHR", "indexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.transformData, settings, "VkDeviceOrHostAddressConstKHR", "transformData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureGeometryAabbsDataKHR(const VkAccelerationStructureGeometryAabbsDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.data, settings, "VkDeviceOrHostAddressConstKHR", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.stride, settings, "VkDeviceSize", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureGeometryInstancesDataKHR(const VkAccelerationStructureGeometryInstancesDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.arrayOfPointers, settings, "VkBool32", "arrayOfPointers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.data, settings, "VkDeviceOrHostAddressConstKHR", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureGeometryDataKHR(const VkAccelerationStructureGeometryDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_union, type_name, var_name, indents, address);
    dump_VkAccelerationStructureGeometryTrianglesDataKHR<Format>(object.triangles, settings, "VkAccelerationStructureGeometryTrianglesDataKHR", "triangles", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureGeometryAabbsDataKHR<Format>(object.aabbs, settings, "VkAccelerationStructureGeometryAabbsDataKHR", "aabbs", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureGeometryInstancesDataKHR<Format>(object.instances, settings, "VkAccelerationStructureGeometryInstancesDataKHR", "instances", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureGeometryKHR(const VkAccelerationStructureGeometryKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGeometryTypeKHR<Format>(object.geometryType, settings, "VkGeometryTypeKHR", "geometryType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureGeometryDataKHR<Format>(object.geometry, settings, "VkAccelerationStructureGeometryDataKHR", "geometry", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkGeometryFlagsKHR<Format>(object.flags, settings, "VkGeometryFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureBuildGeometryInfoKHR(const VkAccelerationStructureBuildGeometryInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureTypeKHR<Format>(object.type, settings, "VkAccelerationStructureTypeKHR", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuildAccelerationStructureFlagsKHR<Format>(object.flags, settings, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuildAccelerationStructureModeKHR<Format>(object.mode, settings, "VkBuildAccelerationStructureModeKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureKHR<Format>(object.srcAccelerationStructure, settings, "VkAccelerationStructureKHR", "srcAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureKHR<Format>(object.dstAccelerationStructure, settings, "VkAccelerationStructureKHR", "dstAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.geometryCount, settings, "uint32_t", "geometryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pGeometries, object.geometryCount, settings, "const VkAccelerationStructureGeometryKHR*", "pGeometries", "const VkAccelerationStructureGeometryKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureGeometryKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_double_pointer_array<Format>(object.ppGeometries, object.geometryCount * 1, settings, "const VkAccelerationStructureGeometryKHR* const*", "ppGeometries", "const VkAccelerationStructureGeometryKHR*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureGeometryKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressKHR<Format>(object.scratchData, settings, "VkDeviceOrHostAddressKHR", "scratchData", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureCreateInfoKHR(const VkAccelerationStructureCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureCreateFlagsKHR<Format>(object.createFlags, settings, "VkAccelerationStructureCreateFlagsKHR", "createFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkBuffer<Format>(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureTypeKHR<Format>(object.type, settings, "VkAccelerationStructureTypeKHR", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type_hex<Format, VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkWriteDescriptorSetAccelerationStructureKHR(const VkWriteDescriptorSetAccelerationStructureKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pAccelerationStructures, object.accelerationStructureCount, settings, "const VkAccelerationStructureKHR*", "pAccelerationStructures", "const VkAccelerationStructureKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureKHR<Format>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceAccelerationStructureFeaturesKHR(const VkPhysicalDeviceAccelerationStructureFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.accelerationStructure, settings, "VkBool32", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.accelerationStructureCaptureReplay, settings, "VkBool32", "accelerationStructureCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.accelerationStructureIndirectBuild, settings, "VkBool32", "accelerationStructureIndirectBuild", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.accelerationStructureHostCommands, settings, "VkBool32", "accelerationStructureHostCommands", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.descriptorBindingAccelerationStructureUpdateAfterBind, settings, "VkBool32", "descriptorBindingAccelerationStructureUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceAccelerationStructurePropertiesKHR(const VkPhysicalDeviceAccelerationStructurePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxGeometryCount, settings, "uint64_t", "maxGeometryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxInstanceCount, settings, "uint64_t", "maxInstanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint64_t>(object.maxPrimitiveCount, settings, "uint64_t", "maxPrimitiveCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorAccelerationStructures, settings, "uint32_t", "maxPerStageDescriptorAccelerationStructures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPerStageDescriptorUpdateAfterBindAccelerationStructures, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindAccelerationStructures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetAccelerationStructures, settings, "uint32_t", "maxDescriptorSetAccelerationStructures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxDescriptorSetUpdateAfterBindAccelerationStructures, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindAccelerationStructures", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.minAccelerationStructureScratchOffsetAlignment, settings, "uint32_t", "minAccelerationStructureScratchOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureDeviceAddressInfoKHR(const VkAccelerationStructureDeviceAddressInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureKHR<Format>(object.accelerationStructure, settings, "VkAccelerationStructureKHR", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkAccelerationStructureVersionInfoKHR(const VkAccelerationStructureVersionInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pVersionData, 2 * VK_UUID_SIZE, settings, "const uint8_t*", "pVersionData", "const uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, const uint8_t>);
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyAccelerationStructureToMemoryInfoKHR(const VkCopyAccelerationStructureToMemoryInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureKHR<Format>(object.src, settings, "VkAccelerationStructureKHR", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressKHR<Format>(object.dst, settings, "VkDeviceOrHostAddressKHR", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCopyAccelerationStructureModeKHR<Format>(object.mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyMemoryToAccelerationStructureInfoKHR(const VkCopyMemoryToAccelerationStructureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkDeviceOrHostAddressConstKHR<Format>(object.src, settings, "VkDeviceOrHostAddressConstKHR", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureKHR<Format>(object.dst, settings, "VkAccelerationStructureKHR", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCopyAccelerationStructureModeKHR<Format>(object.mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkCopyAccelerationStructureInfoKHR(const VkCopyAccelerationStructureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureKHR<Format>(object.src, settings, "VkAccelerationStructureKHR", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkAccelerationStructureKHR<Format>(object.dst, settings, "VkAccelerationStructureKHR", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkCopyAccelerationStructureModeKHR<Format>(object.mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRayTracingShaderGroupCreateInfoKHR(const VkRayTracingShaderGroupCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkRayTracingShaderGroupTypeKHR<Format>(object.type, settings, "VkRayTracingShaderGroupTypeKHR", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.generalShader, settings, "uint32_t", "generalShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.closestHitShader, settings, "uint32_t", "closestHitShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.anyHitShader, settings, "uint32_t", "anyHitShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.intersectionShader, settings, "uint32_t", "intersectionShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, const void*>(object.pShaderGroupCaptureReplayHandle, settings, "const void*", "pShaderGroupCaptureReplayHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRayTracingPipelineInterfaceCreateInfoKHR(const VkRayTracingPipelineInterfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPipelineRayPayloadSize, settings, "uint32_t", "maxPipelineRayPayloadSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPipelineRayHitAttributeSize, settings, "uint32_t", "maxPipelineRayHitAttributeSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkRayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipelineCreateFlags<Format>(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.stageCount, settings, "uint32_t", "stageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.groupCount, settings, "uint32_t", "groupCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer_array<Format>(object.pGroups, object.groupCount, settings, "const VkRayTracingShaderGroupCreateInfoKHR*", "pGroups", "const VkRayTracingShaderGroupCreateInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRayTracingShaderGroupCreateInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPipelineRayRecursionDepth, settings, "uint32_t", "maxPipelineRayRecursionDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pLibraryInfo, settings, "const VkPipelineLibraryCreateInfoKHR*", "pLibraryInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineLibraryCreateInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pLibraryInterface, settings, "const VkRayTracingPipelineInterfaceCreateInfoKHR*", "pLibraryInterface", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRayTracingPipelineInterfaceCreateInfoKHR<Format>);
    dump_separate_members<Format>(settings);
    dump_pointer<Format>(object.pDynamicState, settings, "const VkPipelineDynamicStateCreateInfo*", "pDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineDynamicStateCreateInfo<Format>);
    dump_separate_members<Format>(settings);
    dump_VkPipelineLayout<Format>(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_VkPipeline<Format>(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, int32_t>(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingPipeline, settings, "VkBool32", "rayTracingPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingPipelineShaderGroupHandleCaptureReplay, settings, "VkBool32", "rayTracingPipelineShaderGroupHandleCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingPipelineShaderGroupHandleCaptureReplayMixed, settings, "VkBool32", "rayTracingPipelineShaderGroupHandleCaptureReplayMixed", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTracingPipelineTraceRaysIndirect, settings, "VkBool32", "rayTracingPipelineTraceRaysIndirect", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayTraversalPrimitiveCulling, settings, "VkBool32", "rayTraversalPrimitiveCulling", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderGroupHandleSize, settings, "uint32_t", "shaderGroupHandleSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxRayRecursionDepth, settings, "uint32_t", "maxRayRecursionDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxShaderGroupStride, settings, "uint32_t", "maxShaderGroupStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderGroupBaseAlignment, settings, "uint32_t", "shaderGroupBaseAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderGroupHandleCaptureReplaySize, settings, "uint32_t", "shaderGroupHandleCaptureReplaySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxRayDispatchInvocationCount, settings, "uint32_t", "maxRayDispatchInvocationCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.shaderGroupHandleAlignment, settings, "uint32_t", "shaderGroupHandleAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxRayHitAttributeSize, settings, "uint32_t", "maxRayHitAttributeSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkTraceRaysIndirectCommandKHR(const VkTraceRaysIndirectCommandKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.depth, settings, "uint32_t", "depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceRayQueryFeaturesKHR(const VkPhysicalDeviceRayQueryFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.rayQuery, settings, "VkBool32", "rayQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMeshShaderFeaturesEXT(const VkPhysicalDeviceMeshShaderFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.taskShader, settings, "VkBool32", "taskShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.meshShader, settings, "VkBool32", "meshShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.multiviewMeshShader, settings, "VkBool32", "multiviewMeshShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.primitiveFragmentShadingRateMeshShader, settings, "VkBool32", "primitiveFragmentShadingRateMeshShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.meshShaderQueries, settings, "VkBool32", "meshShaderQueries", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkPhysicalDeviceMeshShaderPropertiesEXT(const VkPhysicalDeviceMeshShaderPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_VkStructureType<Format>(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_pNext<Format>(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTaskWorkGroupTotalCount, settings, "uint32_t", "maxTaskWorkGroupTotalCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxTaskWorkGroupCount, 3, settings, "uint32_t[3]", "maxTaskWorkGroupCount", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTaskWorkGroupInvocations, settings, "uint32_t", "maxTaskWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxTaskWorkGroupSize, 3, settings, "uint32_t[3]", "maxTaskWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTaskPayloadSize, settings, "uint32_t", "maxTaskPayloadSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTaskSharedMemorySize, settings, "uint32_t", "maxTaskSharedMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxTaskPayloadAndSharedMemorySize, settings, "uint32_t", "maxTaskPayloadAndSharedMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshWorkGroupTotalCount, settings, "uint32_t", "maxMeshWorkGroupTotalCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxMeshWorkGroupCount, 3, settings, "uint32_t[3]", "maxMeshWorkGroupCount", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshWorkGroupInvocations, settings, "uint32_t", "maxMeshWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_single_array<Format>(object.maxMeshWorkGroupSize, 3, settings, "uint32_t[3]", "maxMeshWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type<Format, uint32_t>);
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshSharedMemorySize, settings, "uint32_t", "maxMeshSharedMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshPayloadAndSharedMemorySize, settings, "uint32_t", "maxMeshPayloadAndSharedMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshOutputMemorySize, settings, "uint32_t", "maxMeshOutputMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshPayloadAndOutputMemorySize, settings, "uint32_t", "maxMeshPayloadAndOutputMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshOutputComponents, settings, "uint32_t", "maxMeshOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshOutputVertices, settings, "uint32_t", "maxMeshOutputVertices", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshOutputPrimitives, settings, "uint32_t", "maxMeshOutputPrimitives", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshOutputLayers, settings, "uint32_t", "maxMeshOutputLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxMeshMultiviewViewCount, settings, "uint32_t", "maxMeshMultiviewViewCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.meshOutputPerVertexGranularity, settings, "uint32_t", "meshOutputPerVertexGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.meshOutputPerPrimitiveGranularity, settings, "uint32_t", "meshOutputPerPrimitiveGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPreferredTaskWorkGroupInvocations, settings, "uint32_t", "maxPreferredTaskWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.maxPreferredMeshWorkGroupInvocations, settings, "uint32_t", "maxPreferredMeshWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.prefersLocalInvocationVertexOutput, settings, "VkBool32", "prefersLocalInvocationVertexOutput", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.prefersLocalInvocationPrimitiveOutput, settings, "VkBool32", "prefersLocalInvocationPrimitiveOutput", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.prefersCompactVertexOutput, settings, "VkBool32", "prefersCompactVertexOutput", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, VkBool32>(object.prefersCompactPrimitiveOutput, settings, "VkBool32", "prefersCompactPrimitiveOutput", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    if constexpr (Format == ApiDumpFormat::Text) {
        dump_pNext_trampoline<ApiDumpFormat::Text>(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents);
    }
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}
template <ApiDumpFormat Format>
void dump_VkDrawMeshTasksIndirectCommandEXT(const VkDrawMeshTasksIndirectCommandEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) {
    dump_start<Format>(settings, OutputConstruct::api_struct, type_name, var_name, indents, address);
    dump_type<Format, uint32_t>(object.groupCountX, settings, "uint32_t", "groupCountX", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.groupCountY, settings, "uint32_t", "groupCountY", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_separate_members<Format>(settings);
    dump_type<Format, uint32_t>(object.groupCountZ, settings, "uint32_t", "groupCountZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1));
    dump_end<Format>(settings, OutputConstruct::api_struct, indents);
}

//======================== pNext Chain Implementation =======================//

template <ApiDumpFormat Format>
void dump_pNext_struct_name(const void* object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents) {
    if (object == nullptr) {
        dump_nullptr<Format>(settings, type_name, var_name, indents);
        return;
    }
    VkBaseInStructure base_struct{};
    memcpy(&base_struct, object, sizeof(VkBaseInStructure));
    if (base_struct.sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO || base_struct.sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO) {
        if (base_struct.pNext != nullptr) {
            dump_pNext_struct_name<Format>(base_struct.pNext, settings, type_name, var_name, indents);
        } else {
            dump_nullptr<Format>(settings, "const void*", "pNext", indents);
        }
        return;
    }
    dump_start<Format>(settings, OutputConstruct::value, type_name, var_name, indents);
    switch (base_struct.sType) {
        case VK_STRUCTURE_TYPE_APPLICATION_INFO:
            dump_string<Format>(settings, "VkApplicationInfo");
            break;

        case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:
            dump_string<Format>(settings, "VkInstanceCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:
            dump_string<Format>(settings, "VkDeviceQueueCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
            dump_string<Format>(settings, "VkDeviceCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_SUBMIT_INFO:
            dump_string<Format>(settings, "VkSubmitInfo");
            break;

        case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:
            dump_string<Format>(settings, "VkMappedMemoryRange");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
            dump_string<Format>(settings, "VkMemoryAllocateInfo");
            break;

        case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
            dump_string<Format>(settings, "VkBindSparseInfo");
            break;

        case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:
            dump_string<Format>(settings, "VkFenceCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
            dump_string<Format>(settings, "VkSemaphoreCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
            dump_string<Format>(settings, "VkQueryPoolCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
            dump_string<Format>(settings, "VkBufferCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
            dump_string<Format>(settings, "VkImageCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
            dump_string<Format>(settings, "VkImageViewCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:
            dump_string<Format>(settings, "VkCommandPoolCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:
            dump_string<Format>(settings, "VkCommandBufferAllocateInfo");
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:
            dump_string<Format>(settings, "VkCommandBufferInheritanceInfo");
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
            dump_string<Format>(settings, "VkCommandBufferBeginInfo");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
            dump_string<Format>(settings, "VkBufferMemoryBarrier");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
            dump_string<Format>(settings, "VkImageMemoryBarrier");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
            dump_string<Format>(settings, "VkMemoryBarrier");
            break;

        case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:
            dump_string<Format>(settings, "VkEventCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
            dump_string<Format>(settings, "VkBufferViewCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
            dump_string<Format>(settings, "VkShaderModuleCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineCacheCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineShaderStageCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
            dump_string<Format>(settings, "VkComputePipelineCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineLayoutCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
            dump_string<Format>(settings, "VkSamplerCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
            dump_string<Format>(settings, "VkCopyDescriptorSet");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:
            dump_string<Format>(settings, "VkDescriptorPoolCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
            dump_string<Format>(settings, "VkDescriptorSetAllocateInfo");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
            dump_string<Format>(settings, "VkDescriptorSetLayoutCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
            dump_string<Format>(settings, "VkWriteDescriptorSet");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineColorBlendStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineDepthStencilStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineDynamicStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineInputAssemblyStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineMultisampleStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineRasterizationStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineTessellationStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineVertexInputStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineViewportStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
            dump_string<Format>(settings, "VkGraphicsPipelineCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
            dump_string<Format>(settings, "VkFramebufferCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
            dump_string<Format>(settings, "VkRenderPassCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:
            dump_string<Format>(settings, "VkRenderPassBeginInfo");
            break;

        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO:
            dump_string<Format>(settings, "VkBindBufferMemoryInfo");
            break;

        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO:
            dump_string<Format>(settings, "VkBindImageMemoryInfo");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
            dump_string<Format>(settings, "VkMemoryDedicatedRequirements");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
            dump_string<Format>(settings, "VkMemoryDedicatedAllocateInfo");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
            dump_string<Format>(settings, "VkMemoryAllocateFlagsInfo");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
            dump_string<Format>(settings, "VkDeviceGroupCommandBufferBeginInfo");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
            dump_string<Format>(settings, "VkDeviceGroupSubmitInfo");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
            dump_string<Format>(settings, "VkDeviceGroupBindSparseInfo");
            break;

        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
            dump_string<Format>(settings, "VkBindBufferMemoryDeviceGroupInfo");
            break;

        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
            dump_string<Format>(settings, "VkBindImageMemoryDeviceGroupInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceGroupProperties");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
            dump_string<Format>(settings, "VkDeviceGroupDeviceCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2:
            dump_string<Format>(settings, "VkBufferMemoryRequirementsInfo2");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:
            dump_string<Format>(settings, "VkImageMemoryRequirementsInfo2");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2:
            dump_string<Format>(settings, "VkImageSparseMemoryRequirementsInfo2");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2:
            dump_string<Format>(settings, "VkMemoryRequirements2");
            break;

        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2:
            dump_string<Format>(settings, "VkSparseImageMemoryRequirements2");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
            dump_string<Format>(settings, "VkPhysicalDeviceFeatures2");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
            dump_string<Format>(settings, "VkPhysicalDeviceProperties2");
            break;

        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2:
            dump_string<Format>(settings, "VkFormatProperties2");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2:
            dump_string<Format>(settings, "VkImageFormatProperties2");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2:
            dump_string<Format>(settings, "VkPhysicalDeviceImageFormatInfo2");
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2:
            dump_string<Format>(settings, "VkQueueFamilyProperties2");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2:
            dump_string<Format>(settings, "VkPhysicalDeviceMemoryProperties2");
            break;

        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2:
            dump_string<Format>(settings, "VkSparseImageFormatProperties2");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2:
            dump_string<Format>(settings, "VkPhysicalDeviceSparseImageFormatInfo2");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
            dump_string<Format>(settings, "VkImageViewUsageCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceProtectedMemoryFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceProtectedMemoryProperties");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2:
            dump_string<Format>(settings, "VkDeviceQueueInfo2");
            break;

        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
            dump_string<Format>(settings, "VkProtectedSubmitInfo");
            break;

        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
            dump_string<Format>(settings, "VkBindImagePlaneMemoryInfo");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
            dump_string<Format>(settings, "VkImagePlaneMemoryRequirementsInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
            dump_string<Format>(settings, "VkPhysicalDeviceExternalImageFormatInfo");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
            dump_string<Format>(settings, "VkExternalImageFormatProperties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO:
            dump_string<Format>(settings, "VkPhysicalDeviceExternalBufferInfo");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES:
            dump_string<Format>(settings, "VkExternalBufferProperties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceIDProperties");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
            dump_string<Format>(settings, "VkExternalMemoryImageCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
            dump_string<Format>(settings, "VkExternalMemoryBufferCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
            dump_string<Format>(settings, "VkExportMemoryAllocateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO:
            dump_string<Format>(settings, "VkPhysicalDeviceExternalFenceInfo");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES:
            dump_string<Format>(settings, "VkExternalFenceProperties");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
            dump_string<Format>(settings, "VkExportFenceCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
            dump_string<Format>(settings, "VkExportSemaphoreCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO:
            dump_string<Format>(settings, "VkPhysicalDeviceExternalSemaphoreInfo");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES:
            dump_string<Format>(settings, "VkExternalSemaphoreProperties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceSubgroupProperties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDevice16BitStorageFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceVariablePointersFeatures");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO:
            dump_string<Format>(settings, "VkDescriptorUpdateTemplateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance3Properties");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT:
            dump_string<Format>(settings, "VkDescriptorSetLayoutSupport");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO:
            dump_string<Format>(settings, "VkSamplerYcbcrConversionCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
            dump_string<Format>(settings, "VkSamplerYcbcrConversionInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceSamplerYcbcrConversionFeatures");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
            dump_string<Format>(settings, "VkSamplerYcbcrConversionImageFormatProperties");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
            dump_string<Format>(settings, "VkDeviceGroupRenderPassBeginInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDevicePointClippingProperties");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
            dump_string<Format>(settings, "VkRenderPassInputAttachmentAspectCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineTessellationDomainOriginStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
            dump_string<Format>(settings, "VkRenderPassMultiviewCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceMultiviewFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceMultiviewProperties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderDrawParametersFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceDriverProperties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceVulkan11Features");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceVulkan11Properties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceVulkan12Features");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceVulkan12Properties");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
            dump_string<Format>(settings, "VkImageFormatListCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceVulkanMemoryModelFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceHostQueryResetFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceTimelineSemaphoreFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceTimelineSemaphoreProperties");
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
            dump_string<Format>(settings, "VkSemaphoreTypeCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
            dump_string<Format>(settings, "VkTimelineSemaphoreSubmitInfo");
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO:
            dump_string<Format>(settings, "VkSemaphoreWaitInfo");
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO:
            dump_string<Format>(settings, "VkSemaphoreSignalInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceBufferDeviceAddressFeatures");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO:
            dump_string<Format>(settings, "VkBufferDeviceAddressInfo");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
            dump_string<Format>(settings, "VkBufferOpaqueCaptureAddressCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
            dump_string<Format>(settings, "VkMemoryOpaqueCaptureAddressAllocateInfo");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO:
            dump_string<Format>(settings, "VkDeviceMemoryOpaqueCaptureAddressInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDevice8BitStorageFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderAtomicInt64Features");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderFloat16Int8Features");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceFloatControlsProperties");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
            dump_string<Format>(settings, "VkDescriptorSetLayoutBindingFlagsCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorIndexingFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorIndexingProperties");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
            dump_string<Format>(settings, "VkDescriptorSetVariableDescriptorCountAllocateInfo");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
            dump_string<Format>(settings, "VkDescriptorSetVariableDescriptorCountLayoutSupport");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceScalarBlockLayoutFeatures");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
            dump_string<Format>(settings, "VkSamplerReductionModeCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceSamplerFilterMinmaxProperties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceUniformBufferStandardLayoutFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures");
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2:
            dump_string<Format>(settings, "VkAttachmentDescription2");
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2:
            dump_string<Format>(settings, "VkAttachmentReference2");
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2:
            dump_string<Format>(settings, "VkSubpassDescription2");
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2:
            dump_string<Format>(settings, "VkSubpassDependency2");
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO:
            dump_string<Format>(settings, "VkSubpassBeginInfo");
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_END_INFO:
            dump_string<Format>(settings, "VkSubpassEndInfo");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
            dump_string<Format>(settings, "VkRenderPassCreateInfo2");
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
            dump_string<Format>(settings, "VkSubpassDescriptionDepthStencilResolve");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceDepthStencilResolveProperties");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
            dump_string<Format>(settings, "VkImageStencilUsageCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceImagelessFramebufferFeatures");
            break;

        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
            dump_string<Format>(settings, "VkFramebufferAttachmentImageInfo");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
            dump_string<Format>(settings, "VkRenderPassAttachmentBeginInfo");
            break;

        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
            dump_string<Format>(settings, "VkFramebufferAttachmentsCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures");
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
            dump_string<Format>(settings, "VkAttachmentReferenceStencilLayout");
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
            dump_string<Format>(settings, "VkAttachmentDescriptionStencilLayout");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceVulkan13Features");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceVulkan13Properties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceToolProperties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDevicePrivateDataFeatures");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
            dump_string<Format>(settings, "VkDevicePrivateDataCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO:
            dump_string<Format>(settings, "VkPrivateDataSlotCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
            dump_string<Format>(settings, "VkMemoryBarrier2");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2:
            dump_string<Format>(settings, "VkBufferMemoryBarrier2");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2:
            dump_string<Format>(settings, "VkImageMemoryBarrier2");
            break;

        case VK_STRUCTURE_TYPE_DEPENDENCY_INFO:
            dump_string<Format>(settings, "VkDependencyInfo");
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO:
            dump_string<Format>(settings, "VkSemaphoreSubmitInfo");
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO:
            dump_string<Format>(settings, "VkCommandBufferSubmitInfo");
            break;

        case VK_STRUCTURE_TYPE_SUBMIT_INFO_2:
            dump_string<Format>(settings, "VkSubmitInfo2");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceSynchronization2Features");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COPY_2:
            dump_string<Format>(settings, "VkBufferCopy2");
            break;

        case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2:
            dump_string<Format>(settings, "VkCopyBufferInfo2");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_COPY_2:
            dump_string<Format>(settings, "VkImageCopy2");
            break;

        case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2:
            dump_string<Format>(settings, "VkCopyImageInfo2");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2:
            dump_string<Format>(settings, "VkBufferImageCopy2");
            break;

        case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2:
            dump_string<Format>(settings, "VkCopyBufferToImageInfo2");
            break;

        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2:
            dump_string<Format>(settings, "VkCopyImageToBufferInfo2");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceTextureCompressionASTCHDRFeatures");
            break;

        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
            dump_string<Format>(settings, "VkFormatProperties3");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance4Features");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance4Properties");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS:
            dump_string<Format>(settings, "VkDeviceBufferMemoryRequirements");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS:
            dump_string<Format>(settings, "VkDeviceImageMemoryRequirements");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineCreationFeedbackCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderTerminateInvocationFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDevicePipelineCreationCacheControlFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceImageRobustnessFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceSubgroupSizeControlFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceSubgroupSizeControlProperties");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceInlineUniformBlockFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceInlineUniformBlockProperties");
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
            dump_string<Format>(settings, "VkWriteDescriptorSetInlineUniformBlock");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
            dump_string<Format>(settings, "VkDescriptorPoolInlineUniformBlockCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderIntegerDotProductFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderIntegerDotProductProperties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceTexelBufferAlignmentProperties");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_BLIT_2:
            dump_string<Format>(settings, "VkImageBlit2");
            break;

        case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2:
            dump_string<Format>(settings, "VkBlitImageInfo2");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2:
            dump_string<Format>(settings, "VkImageResolve2");
            break;

        case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2:
            dump_string<Format>(settings, "VkResolveImageInfo2");
            break;

        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO:
            dump_string<Format>(settings, "VkRenderingAttachmentInfo");
            break;

        case VK_STRUCTURE_TYPE_RENDERING_INFO:
            dump_string<Format>(settings, "VkRenderingInfo");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineRenderingCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceDynamicRenderingFeatures");
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
            dump_string<Format>(settings, "VkCommandBufferInheritanceRenderingInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceVulkan14Features");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceVulkan14Properties");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO:
            dump_string<Format>(settings, "VkDeviceQueueGlobalPriorityCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceGlobalPriorityQueryFeatures");
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES:
            dump_string<Format>(settings, "VkQueueFamilyGlobalPriorityProperties");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceIndexTypeUint8Features");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO:
            dump_string<Format>(settings, "VkMemoryMapInfo");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO:
            dump_string<Format>(settings, "VkMemoryUnmapInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance5Features");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance5Properties");
            break;

        case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2:
            dump_string<Format>(settings, "VkSubresourceLayout2");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2:
            dump_string<Format>(settings, "VkImageSubresource2");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO:
            dump_string<Format>(settings, "VkDeviceImageSubresourceInfo");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO:
            dump_string<Format>(settings, "VkBufferUsageFlags2CreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance6Features");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance6Properties");
            break;

        case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS:
            dump_string<Format>(settings, "VkBindMemoryStatus");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceHostImageCopyFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceHostImageCopyProperties");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY:
            dump_string<Format>(settings, "VkMemoryToImageCopy");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY:
            dump_string<Format>(settings, "VkImageToMemoryCopy");
            break;

        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO:
            dump_string<Format>(settings, "VkCopyMemoryToImageInfo");
            break;

        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO:
            dump_string<Format>(settings, "VkCopyImageToMemoryInfo");
            break;

        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO:
            dump_string<Format>(settings, "VkCopyImageToImageInfo");
            break;

        case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO:
            dump_string<Format>(settings, "VkHostImageLayoutTransitionInfo");
            break;

        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
            dump_string<Format>(settings, "VkSubresourceHostMemcpySize");
            break;

        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY:
            dump_string<Format>(settings, "VkHostImageCopyDevicePerformanceQuery");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderSubgroupRotateFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderFloatControls2Features");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderExpectAssumeFeatures");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineCreateFlags2CreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDevicePushDescriptorProperties");
            break;

        case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO:
            dump_string<Format>(settings, "VkBindDescriptorSetsInfo");
            break;

        case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO:
            dump_string<Format>(settings, "VkPushConstantsInfo");
            break;

        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO:
            dump_string<Format>(settings, "VkPushDescriptorSetInfo");
            break;

        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO:
            dump_string<Format>(settings, "VkPushDescriptorSetWithTemplateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDevicePipelineProtectedAccessFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDevicePipelineRobustnessFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDevicePipelineRobustnessProperties");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineRobustnessCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceLineRasterizationFeatures");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceLineRasterizationProperties");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineRasterizationLineStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
            dump_string<Format>(settings, "VkPhysicalDeviceVertexAttributeDivisorProperties");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO:
            dump_string<Format>(settings, "VkPipelineVertexInputDivisorStateCreateInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceVertexAttributeDivisorFeatures");
            break;

        case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO:
            dump_string<Format>(settings, "VkRenderingAreaInfo");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
            dump_string<Format>(settings, "VkPhysicalDeviceDynamicRenderingLocalReadFeatures");
            break;

        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO:
            dump_string<Format>(settings, "VkRenderingAttachmentLocationInfo");
            break;

        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO:
            dump_string<Format>(settings, "VkRenderingInputAttachmentIndexInfo");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkSwapchainCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
            dump_string<Format>(settings, "VkPresentInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkImageSwapchainCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
            dump_string<Format>(settings, "VkBindImageMemorySwapchainInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR:
            dump_string<Format>(settings, "VkAcquireNextImageInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkDeviceGroupPresentCapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
            dump_string<Format>(settings, "VkDeviceGroupPresentInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkDeviceGroupSwapchainCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkDisplayModeCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkDisplaySurfaceCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
            dump_string<Format>(settings, "VkDisplayPresentInfoKHR");
            break;
#if defined(VK_USE_PLATFORM_XLIB_KHR)

        case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkXlibSurfaceCreateInfoKHR");
            break;
#endif  // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)

        case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkXcbSurfaceCreateInfoKHR");
            break;
#endif  // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)

        case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkWaylandSurfaceCreateInfoKHR");
            break;
#endif  // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)

        case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkAndroidSurfaceCreateInfoKHR");
            break;
#endif  // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkWin32SurfaceCreateInfoKHR");
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkQueueFamilyQueryResultStatusPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkQueueFamilyVideoPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoProfileInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
            dump_string<Format>(settings, "VkVideoProfileListInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoCapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceVideoFormatInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkVideoFormatPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoPictureResourceInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR:
            dump_string<Format>(settings, "VkVideoReferenceSlotInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR:
            dump_string<Format>(settings, "VkVideoSessionMemoryRequirementsKHR");
            break;

        case VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR:
            dump_string<Format>(settings, "VkBindVideoSessionMemoryInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoSessionCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoSessionParametersCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoSessionParametersUpdateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR:
            dump_string<Format>(settings, "VkVideoBeginCodingInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEndCodingInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR:
            dump_string<Format>(settings, "VkVideoCodingControlInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoDecodeCapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeUsageInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264CapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264QualityLevelPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264SessionCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264SessionParametersAddInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264SessionParametersCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264SessionParametersGetInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264SessionParametersFeedbackInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264NaluSliceInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264PictureInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264DpbSlotInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264ProfileInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264RateControlInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264RateControlLayerInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264GopRemainingFrameInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265CapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265SessionCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265QualityLevelPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265SessionParametersAddInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265SessionParametersCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265SessionParametersGetInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265SessionParametersFeedbackInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265NaluSliceSegmentInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265PictureInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265DpbSlotInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265ProfileInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265RateControlInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265RateControlLayerInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265GopRemainingFrameInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH264ProfileInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH264CapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH264SessionParametersAddInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH264SessionParametersCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH264PictureInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH264DpbSlotInfoKHR");
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
            dump_string<Format>(settings, "VkImportMemoryWin32HandleInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
            dump_string<Format>(settings, "VkExportMemoryWin32HandleInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkMemoryWin32HandlePropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
            dump_string<Format>(settings, "VkMemoryGetWin32HandleInfoKHR");
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
            dump_string<Format>(settings, "VkImportMemoryFdInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkMemoryFdPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR:
            dump_string<Format>(settings, "VkMemoryGetFdInfoKHR");
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
            dump_string<Format>(settings, "VkWin32KeyedMutexAcquireReleaseInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
            dump_string<Format>(settings, "VkImportSemaphoreWin32HandleInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
            dump_string<Format>(settings, "VkExportSemaphoreWin32HandleInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
            dump_string<Format>(settings, "VkD3D12FenceSubmitInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
            dump_string<Format>(settings, "VkSemaphoreGetWin32HandleInfoKHR");
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR:
            dump_string<Format>(settings, "VkImportSemaphoreFdInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:
            dump_string<Format>(settings, "VkSemaphoreGetFdInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
            dump_string<Format>(settings, "VkPresentRegionsKHR");
            break;

        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkSharedPresentSurfaceCapabilitiesKHR");
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
            dump_string<Format>(settings, "VkImportFenceWin32HandleInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
            dump_string<Format>(settings, "VkExportFenceWin32HandleInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
            dump_string<Format>(settings, "VkFenceGetWin32HandleInfoKHR");
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR:
            dump_string<Format>(settings, "VkImportFenceFdInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR:
            dump_string<Format>(settings, "VkFenceGetFdInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePerformanceQueryFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePerformanceQueryPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR:
            dump_string<Format>(settings, "VkPerformanceCounterKHR");
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR:
            dump_string<Format>(settings, "VkPerformanceCounterDescriptionKHR");
            break;

        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkQueryPoolPerformanceCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR:
            dump_string<Format>(settings, "VkAcquireProfilingLockInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
            dump_string<Format>(settings, "VkPerformanceQuerySubmitInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceSurfaceInfo2KHR");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR:
            dump_string<Format>(settings, "VkSurfaceCapabilities2KHR");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR:
            dump_string<Format>(settings, "VkSurfaceFormat2KHR");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR:
            dump_string<Format>(settings, "VkDisplayProperties2KHR");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR:
            dump_string<Format>(settings, "VkDisplayPlaneProperties2KHR");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR:
            dump_string<Format>(settings, "VkDisplayModeProperties2KHR");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR:
            dump_string<Format>(settings, "VkDisplayPlaneInfo2KHR");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR:
            dump_string<Format>(settings, "VkDisplayPlaneCapabilities2KHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderBfloat16FeaturesKHR");
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePortabilitySubsetFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePortabilitySubsetPropertiesKHR");
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderClockFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH265ProfileInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH265CapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH265SessionParametersAddInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH265SessionParametersCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH265PictureInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH265DpbSlotInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
            dump_string<Format>(settings, "VkFragmentShadingRateAttachmentInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkPipelineFragmentShadingRateStateCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShadingRateFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShadingRatePropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShadingRateKHR");
            break;

        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
            dump_string<Format>(settings, "VkRenderingFragmentShadingRateAttachmentInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderConstantDataFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderAbortFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR:
            dump_string<Format>(settings, "VkDeviceFaultShaderAbortMessageInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderAbortPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderQuadControlFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkSurfaceProtectedCapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePresentWaitFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR:
            dump_string<Format>(settings, "VkPipelineInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPipelineExecutablePropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR:
            dump_string<Format>(settings, "VkPipelineExecutableInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR:
            dump_string<Format>(settings, "VkPipelineExecutableStatisticKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR:
            dump_string<Format>(settings, "VkPipelineExecutableInternalRepresentationKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkPipelineLibraryCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
            dump_string<Format>(settings, "VkPresentIdKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePresentIdFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeCapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkQueryPoolVideoEncodeFeedbackCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeUsageInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeRateControlLayerInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeRateControlInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeQualityLevelPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeQualityLevelInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeSessionParametersGetInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeSessionParametersFeedbackInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR:
            dump_string<Format>(settings, "VkDeviceMemoryCopyKHR");
            break;

        case VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR:
            dump_string<Format>(settings, "VkCopyDeviceMemoryInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR:
            dump_string<Format>(settings, "VkDeviceMemoryImageCopyKHR");
            break;

        case VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR:
            dump_string<Format>(settings, "VkCopyDeviceMemoryImageInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR:
            dump_string<Format>(settings, "VkMemoryRangeBarrierKHR");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR:
            dump_string<Format>(settings, "VkMemoryRangeBarriersInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR:
            dump_string<Format>(settings, "VkBindIndexBuffer3InfoKHR");
            break;

        case VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR:
            dump_string<Format>(settings, "VkBindVertexBuffer3InfoKHR");
            break;

        case VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR:
            dump_string<Format>(settings, "VkDrawIndirect2InfoKHR");
            break;

        case VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR:
            dump_string<Format>(settings, "VkDrawIndirectCount2InfoKHR");
            break;

        case VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR:
            dump_string<Format>(settings, "VkDispatchIndirect2InfoKHR");
            break;

        case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT:
            dump_string<Format>(settings, "VkConditionalRenderingBeginInfo2EXT");
            break;

        case VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT:
            dump_string<Format>(settings, "VkBindTransformFeedbackBuffer2InfoEXT");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD:
            dump_string<Format>(settings, "VkMemoryMarkerInfoAMD");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureCreateInfo2KHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR:
            dump_string<Format>(settings, "VkSurfaceCapabilitiesPresentId2KHR");
            break;

        case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR:
            dump_string<Format>(settings, "VkPresentId2KHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePresentId2FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR:
            dump_string<Format>(settings, "VkSurfaceCapabilitiesPresentWait2KHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePresentWait2FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR:
            dump_string<Format>(settings, "VkPresentWait2InfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePipelineBinaryFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePipelineBinaryPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
            dump_string<Format>(settings, "VkDevicePipelineBinaryInternalCacheControlKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR:
            dump_string<Format>(settings, "VkPipelineBinaryKeyKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkPipelineCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkPipelineBinaryCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
            dump_string<Format>(settings, "VkPipelineBinaryInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR:
            dump_string<Format>(settings, "VkReleaseCapturedPipelineDataInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR:
            dump_string<Format>(settings, "VkPipelineBinaryDataInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR:
            dump_string<Format>(settings, "VkPipelineBinaryHandlesInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR:
            dump_string<Format>(settings, "VkSurfacePresentModeKHR");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkSurfacePresentScalingCapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR:
            dump_string<Format>(settings, "VkSurfacePresentModeCompatibilityKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR:
            dump_string<Format>(settings, "VkSwapchainPresentFenceInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkSwapchainPresentModesCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR:
            dump_string<Format>(settings, "VkSwapchainPresentModeInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkSwapchainPresentScalingCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR:
            dump_string<Format>(settings, "VkReleaseSwapchainImagesInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkCooperativeMatrixPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrixFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrixPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeAV1ProfileInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoDecodeAV1CapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeAV1SessionParametersCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeAV1PictureInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeAV1DpbSlotInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeAV1CapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeAV1QualityLevelPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeAV1SessionCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeAV1SessionParametersCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeAV1PictureInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeAV1DpbSlotInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeAV1ProfileInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeAV1GopRemainingFrameInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeAV1RateControlInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeAV1RateControlLayerInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeVP9ProfileInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoDecodeVP9CapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeVP9PictureInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceVideoMaintenance1FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
            dump_string<Format>(settings, "VkVideoInlineQueryInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
            dump_string<Format>(settings, "VkAttachmentFeedbackLoopInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR:
            dump_string<Format>(settings, "VkCalibratedTimestampInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT:
            dump_string<Format>(settings, "VkSetDescriptorBufferOffsetsInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT:
            dump_string<Format>(settings, "VkBindDescriptorBufferEmbeddedSamplersInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR:
            dump_string<Format>(settings, "VkCopyMemoryIndirectInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR:
            dump_string<Format>(settings, "VkCopyMemoryToImageIndirectInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeIntraRefreshCapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeSessionIntraRefreshCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeIntraRefreshInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR:
            dump_string<Format>(settings, "VkVideoReferenceIntraRefreshInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeQuantizationMapCapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkVideoFormatQuantizationMapPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeQuantizationMapInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH264QuantizationMapCapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeH265QuantizationMapCapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkVideoFormatH265QuantizationMapPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkVideoFormatAV1QuantizationMapPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance7FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance7PropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceLayeredApiPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceLayeredApiPropertiesListKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceFaultFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceFaultPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR:
            dump_string<Format>(settings, "VkDeviceFaultInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR:
            dump_string<Format>(settings, "VkDeviceFaultDebugInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
            dump_string<Format>(settings, "VkMemoryBarrierAccessFlags3KHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance8FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderFmaFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance9FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance9PropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkQueueFamilyOwnershipTransferPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceVideoMaintenance2FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH264InlineSessionParametersInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeH265InlineSessionParametersInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR:
            dump_string<Format>(settings, "VkVideoDecodeAV1InlineSessionParametersInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR:
            dump_string<Format>(settings, "VkVideoEncodeFeedback2CapabilitiesKHR");
            break;

        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceRobustness2FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceRobustness2PropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureGeometryMicromapDataKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceOpacityMicromapFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceOpacityMicromapPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureTrianglesOpacityMicromapKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance10FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance10PropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR:
            dump_string<Format>(settings, "VkRenderingEndInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR:
            dump_string<Format>(settings, "VkRenderingAttachmentFlagsInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR:
            dump_string<Format>(settings, "VkResolveImageModeInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceMaintenance11FeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR:
            dump_string<Format>(settings, "VkFormatProperties4KHR");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkImageUsageFlags2CreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkImageCreateFlags2CreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkImageViewUsage2CreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceExtendedFlagsFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkImageStencilUsage2CreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR:
            dump_string<Format>(settings, "VkSharedPresentSurfaceCapabilities2KHR");
            break;

        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkDebugReportCallbackCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
            dump_string<Format>(settings, "VkPipelineRasterizationStateRasterizationOrderAMD");
            break;

        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
            dump_string<Format>(settings, "VkDebugMarkerObjectNameInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
            dump_string<Format>(settings, "VkDebugMarkerObjectTagInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT:
            dump_string<Format>(settings, "VkDebugMarkerMarkerInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkDedicatedAllocationImageCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkDedicatedAllocationBufferCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
            dump_string<Format>(settings, "VkDedicatedAllocationMemoryAllocateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceTransformFeedbackFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceTransformFeedbackPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkPipelineRasterizationStateStreamCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX:
            dump_string<Format>(settings, "VkCuModuleCreateInfoNVX");
            break;

        case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
            dump_string<Format>(settings, "VkCuModuleTexturingModeCreateInfoNVX");
            break;

        case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX:
            dump_string<Format>(settings, "VkCuFunctionCreateInfoNVX");
            break;

        case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX:
            dump_string<Format>(settings, "VkCuLaunchInfoNVX");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX:
            dump_string<Format>(settings, "VkImageViewHandleInfoNVX");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX:
            dump_string<Format>(settings, "VkImageViewAddressPropertiesNVX");
            break;

        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
            dump_string<Format>(settings, "VkTextureLODGatherFormatPropertiesAMD");
            break;
#if defined(VK_USE_PLATFORM_GGP)

        case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP:
            dump_string<Format>(settings, "VkStreamDescriptorSurfaceCreateInfoGGP");
            break;
#endif  // VK_USE_PLATFORM_GGP

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCornerSampledImageFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkExternalMemoryImageCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
            dump_string<Format>(settings, "VkExportMemoryAllocateInfoNV");
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
            dump_string<Format>(settings, "VkImportMemoryWin32HandleInfoNV");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
            dump_string<Format>(settings, "VkExportMemoryWin32HandleInfoNV");
            break;

        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
            dump_string<Format>(settings, "VkWin32KeyedMutexAcquireReleaseInfoNV");
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
            dump_string<Format>(settings, "VkValidationFlagsEXT");
            break;
#if defined(VK_USE_PLATFORM_VI_NN)

        case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN:
            dump_string<Format>(settings, "VkViSurfaceCreateInfoNN");
            break;
#endif  // VK_USE_PLATFORM_VI_NN

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
            dump_string<Format>(settings, "VkImageViewASTCDecodeModeEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceASTCDecodeFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT:
            dump_string<Format>(settings, "VkConditionalRenderingBeginInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceConditionalRenderingFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
            dump_string<Format>(settings, "VkCommandBufferInheritanceConditionalRenderingInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkPipelineViewportWScalingStateCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT:
            dump_string<Format>(settings, "VkSurfaceCapabilities2EXT");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT:
            dump_string<Format>(settings, "VkDisplayPowerInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT:
            dump_string<Format>(settings, "VkDeviceEventInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT:
            dump_string<Format>(settings, "VkDisplayEventInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkSwapchainCounterCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
            dump_string<Format>(settings, "VkPresentTimesInfoGOOGLE");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
            dump_string<Format>(settings, "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX");
            break;

        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
            dump_string<Format>(settings, "VkMultiviewPerViewAttributesInfoNVX");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkPipelineViewportSwizzleStateCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDiscardRectanglePropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkPipelineDiscardRectangleStateCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceConservativeRasterizationPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkPipelineRasterizationConservativeStateCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDepthClipEnableFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkPipelineRasterizationDepthClipStateCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_HDR_METADATA_EXT:
            dump_string<Format>(settings, "VkHdrMetadataEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
            dump_string<Format>(settings, "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG");
            break;
#if defined(VK_USE_PLATFORM_IOS_MVK)

        case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK:
            dump_string<Format>(settings, "VkIOSSurfaceCreateInfoMVK");
            break;
#endif  // VK_USE_PLATFORM_IOS_MVK
#if defined(VK_USE_PLATFORM_MACOS_MVK)

        case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK:
            dump_string<Format>(settings, "VkMacOSSurfaceCreateInfoMVK");
            break;
#endif  // VK_USE_PLATFORM_MACOS_MVK

        case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT:
            dump_string<Format>(settings, "VkDebugUtilsLabelEXT");
            break;

        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
            dump_string<Format>(settings, "VkDebugUtilsObjectNameInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
            dump_string<Format>(settings, "VkDebugUtilsMessengerCallbackDataEXT");
            break;

        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkDebugUtilsMessengerCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
            dump_string<Format>(settings, "VkDebugUtilsObjectTagInfoEXT");
            break;
#if defined(VK_USE_PLATFORM_ANDROID_KHR)

        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
            dump_string<Format>(settings, "VkAndroidHardwareBufferUsageANDROID");
            break;

        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
            dump_string<Format>(settings, "VkAndroidHardwareBufferPropertiesANDROID");
            break;

        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
            dump_string<Format>(settings, "VkAndroidHardwareBufferFormatPropertiesANDROID");
            break;

        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
            dump_string<Format>(settings, "VkImportAndroidHardwareBufferInfoANDROID");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
            dump_string<Format>(settings, "VkMemoryGetAndroidHardwareBufferInfoANDROID");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
            dump_string<Format>(settings, "VkExternalFormatANDROID");
            break;

        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
            dump_string<Format>(settings, "VkAndroidHardwareBufferFormatProperties2ANDROID");
            break;
#endif  // VK_USE_PLATFORM_ANDROID_KHR

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD:
            dump_string<Format>(settings, "VkPhysicalDeviceGpaFeaturesAMD");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD:
            dump_string<Format>(settings, "VkPhysicalDeviceGpaPropertiesAMD");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD:
            dump_string<Format>(settings, "VkPhysicalDeviceGpaProperties2AMD");
            break;

        case VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD:
            dump_string<Format>(settings, "VkGpaSampleBeginInfoAMD");
            break;

        case VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD:
            dump_string<Format>(settings, "VkGpaDeviceClockModeInfoAMD");
            break;

        case VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD:
            dump_string<Format>(settings, "VkGpaDeviceGetClockInfoAMD");
            break;

        case VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD:
            dump_string<Format>(settings, "VkGpaSessionCreateInfoAMD");
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderEnqueueFeaturesAMDX");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderEnqueuePropertiesAMDX");
            break;

        case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX:
            dump_string<Format>(settings, "VkExecutionGraphPipelineScratchSizeAMDX");
            break;

        case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
            dump_string<Format>(settings, "VkExecutionGraphPipelineCreateInfoAMDX");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
            dump_string<Format>(settings, "VkPipelineShaderStageNodeCreateInfoAMDX");
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS

        case VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT:
            dump_string<Format>(settings, "VkTexelBufferDescriptorInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT:
            dump_string<Format>(settings, "VkImageDescriptorInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkTensorViewCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT:
            dump_string<Format>(settings, "VkResourceDescriptorInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT:
            dump_string<Format>(settings, "VkBindHeapInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT:
            dump_string<Format>(settings, "VkPushDataInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT:
            dump_string<Format>(settings, "VkDescriptorSetAndBindingMappingEXT");
            break;

        case VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT:
            dump_string<Format>(settings, "VkShaderDescriptorSetAndBindingMappingInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkOpaqueCaptureDataCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorHeapFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorHeapPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT:
            dump_string<Format>(settings, "VkCommandBufferInheritanceDescriptorHeapInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkSamplerCustomBorderColorIndexCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkSamplerCustomBorderColorCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV:
            dump_string<Format>(settings, "VkIndirectCommandsLayoutPushDataTokenNV");
            break;

        case VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkSubsampledImageFormatPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorHeapTensorPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
            dump_string<Format>(settings, "VkAttachmentSampleCountInfoAMD");
            break;

        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
            dump_string<Format>(settings, "VkSampleLocationsInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
            dump_string<Format>(settings, "VkRenderPassSampleLocationsBeginInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkPipelineSampleLocationsStateCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceSampleLocationsPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkMultisamplePropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkPipelineColorBlendAdvancedStateCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkPipelineCoverageToColorStateCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkPipelineCoverageModulationStateCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderSMBuiltinsPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
            dump_string<Format>(settings, "VkDrmFormatModifierPropertiesListEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceImageDrmFormatModifierInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkImageDrmFormatModifierListCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkImageDrmFormatModifierExplicitCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkImageDrmFormatModifierPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
            dump_string<Format>(settings, "VkDrmFormatModifierPropertiesList2EXT");
            break;

        case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkValidationCacheCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkShaderModuleValidationCacheCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkPipelineViewportShadingRateImageStateCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceShadingRateImageFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceShadingRateImagePropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkRayTracingShaderGroupCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkRayTracingPipelineCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV:
            dump_string<Format>(settings, "VkGeometryTrianglesNV");
            break;

        case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV:
            dump_string<Format>(settings, "VkGeometryAABBNV");
            break;

        case VK_STRUCTURE_TYPE_GEOMETRY_NV:
            dump_string<Format>(settings, "VkGeometryNV");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV:
            dump_string<Format>(settings, "VkAccelerationStructureInfoNV");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkAccelerationStructureCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV:
            dump_string<Format>(settings, "VkBindAccelerationStructureMemoryInfoNV");
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
            dump_string<Format>(settings, "VkWriteDescriptorSetAccelerationStructureNV");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV:
            dump_string<Format>(settings, "VkAccelerationStructureMemoryRequirementsInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkPipelineRepresentativeFragmentTestStateCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceImageViewImageFormatInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkFilterCubicImageViewImageFormatPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
            dump_string<Format>(settings, "VkImportMemoryHostPointerInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkMemoryHostPointerPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceExternalMemoryHostPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
            dump_string<Format>(settings, "VkPipelineCompilerControlCreateInfoAMD");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderCorePropertiesAMD");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
            dump_string<Format>(settings, "VkDeviceMemoryOverallocationCreateInfoAMD");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT");
            break;
#if defined(VK_USE_PLATFORM_GGP)

        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
            dump_string<Format>(settings, "VkPresentFrameTokenGGP");
            break;
#endif  // VK_USE_PLATFORM_GGP

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceMeshShaderFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceMeshShaderPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderImageFootprintFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkPipelineViewportExclusiveScissorStateCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceExclusiveScissorFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
            dump_string<Format>(settings, "VkQueueFamilyCheckpointPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV:
            dump_string<Format>(settings, "VkCheckpointDataNV");
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
            dump_string<Format>(settings, "VkQueueFamilyCheckpointProperties2NV");
            break;

        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV:
            dump_string<Format>(settings, "VkCheckpointData2NV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDevicePresentTimingFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT:
            dump_string<Format>(settings, "VkPresentTimingSurfaceCapabilitiesEXT");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT:
            dump_string<Format>(settings, "VkSwapchainCalibratedTimestampInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkSwapchainTimingPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkSwapchainTimeDomainPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT:
            dump_string<Format>(settings, "VkPastPresentationTimingInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT:
            dump_string<Format>(settings, "VkPastPresentationTimingEXT");
            break;

        case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPastPresentationTimingPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT:
            dump_string<Format>(settings, "VkPresentTimingInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT:
            dump_string<Format>(settings, "VkPresentTimingsInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL");
            break;

        case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL:
            dump_string<Format>(settings, "VkInitializePerformanceApiInfoINTEL");
            break;

        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
            dump_string<Format>(settings, "VkQueryPoolPerformanceQueryCreateInfoINTEL");
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL:
            dump_string<Format>(settings, "VkPerformanceMarkerInfoINTEL");
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL:
            dump_string<Format>(settings, "VkPerformanceStreamMarkerInfoINTEL");
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL:
            dump_string<Format>(settings, "VkPerformanceOverrideInfoINTEL");
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL:
            dump_string<Format>(settings, "VkPerformanceConfigurationAcquireInfoINTEL");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDevicePCIBusInfoPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
            dump_string<Format>(settings, "VkDisplayNativeHdrSurfaceCapabilitiesAMD");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
            dump_string<Format>(settings, "VkSwapchainDisplayNativeHdrCreateInfoAMD");
            break;
#if defined(VK_USE_PLATFORM_FUCHSIA)

        case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkImagePipeSurfaceCreateInfoFUCHSIA");
            break;
#endif  // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_METAL_EXT)

        case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkMetalSurfaceCreateInfoEXT");
            break;
#endif  // VK_USE_PLATFORM_METAL_EXT

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkRenderPassFragmentDensityMapCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
            dump_string<Format>(settings, "VkRenderingFragmentDensityMapAttachmentInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderCoreProperties2AMD");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
            dump_string<Format>(settings, "VkPhysicalDeviceCoherentMemoryFeaturesAMD");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMemoryBudgetPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMemoryPriorityFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
            dump_string<Format>(settings, "VkMemoryPriorityAllocateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkBufferDeviceAddressCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
            dump_string<Format>(settings, "VkValidationFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV:
            dump_string<Format>(settings, "VkCooperativeMatrixPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrixFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrixPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCoverageReductionModeFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkPipelineCoverageReductionStateCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV:
            dump_string<Format>(settings, "VkFramebufferMixedSamplesCombinationNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceProvokingVertexFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceProvokingVertexPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT");
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
            dump_string<Format>(settings, "VkSurfaceFullScreenExclusiveInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
            dump_string<Format>(settings, "VkSurfaceCapabilitiesFullScreenExclusiveEXT");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
            dump_string<Format>(settings, "VkSurfaceFullScreenExclusiveWin32InfoEXT");
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkHeadlessSurfaceCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
            dump_string<Format>(settings, "VkMemoryMapPlacedInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkGraphicsShaderGroupCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkGraphicsPipelineShaderGroupsCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV:
            dump_string<Format>(settings, "VkIndirectCommandsLayoutTokenNV");
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkIndirectCommandsLayoutCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV:
            dump_string<Format>(settings, "VkGeneratedCommandsInfoNV");
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV:
            dump_string<Format>(settings, "VkGeneratedCommandsMemoryRequirementsInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceInheritedViewportScissorFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
            dump_string<Format>(settings, "VkCommandBufferInheritanceViewportScissorInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
            dump_string<Format>(settings, "VkRenderPassTransformBeginInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
            dump_string<Format>(settings, "VkCommandBufferInheritanceRenderPassTransformInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDepthBiasControlFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT:
            dump_string<Format>(settings, "VkDepthBiasInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
            dump_string<Format>(settings, "VkDepthBiasRepresentationInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT:
            dump_string<Format>(settings, "VkDeviceMemoryReportCallbackDataEXT");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkDeviceDeviceMemoryReportCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceCustomBorderColorPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceCustomBorderColorFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDevicePresentBarrierFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
            dump_string<Format>(settings, "VkSurfaceCapabilitiesPresentBarrierNV");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkSwapchainPresentBarrierCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceDiagnosticsConfigFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkDeviceDiagnosticsConfigCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM:
            dump_string<Format>(settings, "VkPerfHintInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceQueuePerfHintFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceQueuePerfHintPropertiesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceImageProcessing3FeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderSplitBarrierFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderSplitBarrierPropertiesEXT");
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)

        case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkCudaModuleCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkCudaFunctionCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV:
            dump_string<Format>(settings, "VkCudaLaunchInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCudaKernelLaunchFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCudaKernelLaunchPropertiesNV");
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceTileShadingFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceTileShadingPropertiesQCOM");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
            dump_string<Format>(settings, "VkRenderPassTileShadingCreateInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM:
            dump_string<Format>(settings, "VkPerTileBeginInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM:
            dump_string<Format>(settings, "VkPerTileEndInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM:
            dump_string<Format>(settings, "VkDispatchTileInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
            dump_string<Format>(settings, "VkQueryLowLatencySupportNV");
            break;
#if defined(VK_USE_PLATFORM_METAL_EXT)

        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkExportMetalObjectCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT:
            dump_string<Format>(settings, "VkExportMetalObjectsInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
            dump_string<Format>(settings, "VkExportMetalDeviceInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
            dump_string<Format>(settings, "VkExportMetalCommandQueueInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
            dump_string<Format>(settings, "VkExportMetalBufferInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
            dump_string<Format>(settings, "VkImportMetalBufferInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
            dump_string<Format>(settings, "VkExportMetalTextureInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
            dump_string<Format>(settings, "VkImportMetalTextureInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
            dump_string<Format>(settings, "VkExportMetalIOSurfaceInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
            dump_string<Format>(settings, "VkImportMetalIOSurfaceInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
            dump_string<Format>(settings, "VkExportMetalSharedEventInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
            dump_string<Format>(settings, "VkImportMetalSharedEventInfoEXT");
            break;
#endif  // VK_USE_PLATFORM_METAL_EXT

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorBufferPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorBufferFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT:
            dump_string<Format>(settings, "VkDescriptorAddressInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT:
            dump_string<Format>(settings, "VkDescriptorBufferBindingInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
            dump_string<Format>(settings, "VkDescriptorBufferBindingPushDescriptorBufferHandleEXT");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT:
            dump_string<Format>(settings, "VkDescriptorGetInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_string<Format>(settings, "VkBufferCaptureDescriptorDataInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_string<Format>(settings, "VkImageCaptureDescriptorDataInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_string<Format>(settings, "VkImageViewCaptureDescriptorDataInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_string<Format>(settings, "VkSamplerCaptureDescriptorDataInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkOpaqueCaptureDescriptorDataCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_string<Format>(settings, "VkAccelerationStructureCaptureDescriptorDataInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkGraphicsPipelineLibraryCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkPipelineFragmentShadingRateEnumStateCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
            dump_string<Format>(settings, "VkAccelerationStructureGeometryMotionTrianglesDataNV");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
            dump_string<Format>(settings, "VkAccelerationStructureMotionInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
            dump_string<Format>(settings, "VkCopyCommandTransformInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceImageCompressionControlFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
            dump_string<Format>(settings, "VkImageCompressionControlEXT");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkImageCompressionPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDevice4444FormatsFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceFaultFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT:
            dump_string<Format>(settings, "VkDeviceFaultCountsEXT");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT:
            dump_string<Format>(settings, "VkDeviceFaultInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT");
            break;
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)

        case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkDirectFBSurfaceCreateInfoEXT");
            break;
#endif  // VK_USE_PLATFORM_DIRECTFB_EXT

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkMutableDescriptorTypeCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT:
            dump_string<Format>(settings, "VkVertexInputBindingDescription2EXT");
            break;

        case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT:
            dump_string<Format>(settings, "VkVertexInputAttributeDescription2EXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDrmPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceAddressBindingReportFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
            dump_string<Format>(settings, "VkDeviceAddressBindingCallbackDataEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDepthClipControlFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkPipelineViewportDepthClipControlCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT");
            break;
#if defined(VK_USE_PLATFORM_FUCHSIA)

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkImportMemoryZirconHandleInfoFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA:
            dump_string<Format>(settings, "VkMemoryZirconHandlePropertiesFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkMemoryGetZirconHandleInfoFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkImportSemaphoreZirconHandleInfoFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkSemaphoreGetZirconHandleInfoFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkBufferCollectionCreateInfoFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
            dump_string<Format>(settings, "VkImportMemoryBufferCollectionFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkBufferCollectionImageCreateInfoFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkBufferCollectionConstraintsInfoFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkBufferConstraintsInfoFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkBufferCollectionBufferCreateInfoFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA:
            dump_string<Format>(settings, "VkSysmemColorSpaceFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA:
            dump_string<Format>(settings, "VkBufferCollectionPropertiesFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkImageFormatConstraintsInfoFUCHSIA");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA:
            dump_string<Format>(settings, "VkImageConstraintsInfoFUCHSIA");
            break;
#endif  // VK_USE_PLATFORM_FUCHSIA

        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
            dump_string<Format>(settings, "VkSubpassShadingPipelineCreateInfoHUAWEI");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
            dump_string<Format>(settings, "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
            dump_string<Format>(settings, "VkPhysicalDeviceSubpassShadingPropertiesHUAWEI");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
            dump_string<Format>(settings, "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV:
            dump_string<Format>(settings, "VkMemoryGetRemoteAddressInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT:
            dump_string<Format>(settings, "VkPipelinePropertiesIdentifierEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDevicePipelinePropertiesFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceFrameBoundaryFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
            dump_string<Format>(settings, "VkFrameBoundaryEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
            dump_string<Format>(settings, "VkSubpassResolvePerformanceQueryEXT");
            break;

        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
            dump_string<Format>(settings, "VkMultisampledRenderToSingleSampledInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT");
            break;
#if defined(VK_USE_PLATFORM_SCREEN_QNX)

        case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX:
            dump_string<Format>(settings, "VkScreenSurfaceCreateInfoQNX");
            break;
#endif  // VK_USE_PLATFORM_SCREEN_QNX

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceColorWriteEnableFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkPipelineColorWriteCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
            dump_string<Format>(settings, "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE:
            dump_string<Format>(settings, "VkVideoEncodeRgbConversionCapabilitiesVALVE");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE:
            dump_string<Format>(settings, "VkVideoEncodeProfileRgbConversionInfoVALVE");
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE:
            dump_string<Format>(settings, "VkVideoEncodeSessionRgbConversionCreateInfoVALVE");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceImageViewMinLodFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkImageViewMinLodCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMultiDrawFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMultiDrawPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderTileImageFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderTileImagePropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT:
            dump_string<Format>(settings, "VkMicromapBuildInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkMicromapCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceOpacityMicromapFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceOpacityMicromapPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT:
            dump_string<Format>(settings, "VkMicromapVersionInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT:
            dump_string<Format>(settings, "VkCopyMicromapToMemoryInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT:
            dump_string<Format>(settings, "VkCopyMemoryToMicromapInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT:
            dump_string<Format>(settings, "VkCopyMicromapInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT:
            dump_string<Format>(settings, "VkMicromapBuildSizesInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
            dump_string<Format>(settings, "VkAccelerationStructureTrianglesOpacityMicromapEXT");
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceDisplacementMicromapFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceDisplacementMicromapPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
            dump_string<Format>(settings, "VkAccelerationStructureTrianglesDisplacementMicromapNV");
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
            dump_string<Format>(settings, "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
            dump_string<Format>(settings, "VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI:
            dump_string<Format>(settings, "VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkSamplerBorderColorComponentMappingCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderCorePropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkDeviceQueueShaderCoreControlCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceSchedulingControlsFeaturesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceSchedulingControlsPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_DISPATCH_PARAMETERS_ARM:
            dump_string<Format>(settings, "VkDispatchParametersARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkImageViewSlicedCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE:
            dump_string<Format>(settings, "VkDescriptorSetBindingReferenceVALVE");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE:
            dump_string<Format>(settings, "VkDescriptorSetLayoutHostMappingInfoVALVE");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceRenderPassStripedFeaturesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceRenderPassStripedPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM:
            dump_string<Format>(settings, "VkRenderPassStripeInfoARM");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
            dump_string<Format>(settings, "VkRenderPassStripeBeginInfoARM");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
            dump_string<Format>(settings, "VkRenderPassStripeSubmitInfoARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT:
            dump_string<Format>(settings, "VkRenderPassFragmentDensityMapOffsetEndInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMemoryDecompressionFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMemoryDecompressionPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
            dump_string<Format>(settings, "VkComputePipelineIndirectBufferInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV:
            dump_string<Format>(settings, "VkPipelineIndirectDeviceAddressInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV:
            dump_string<Format>(settings, "VkAccelerationStructureGeometryLinearSweptSpheresDataNV");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV:
            dump_string<Format>(settings, "VkAccelerationStructureGeometrySpheresDataNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceLinearColorAttachmentFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
            dump_string<Format>(settings, "VkImageViewSampleWeightCreateInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceImageProcessingFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceImageProcessingPropertiesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceNestedCommandBufferFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceNestedCommandBufferPropertiesEXT");
            break;
#if defined(VK_USE_PLATFORM_OHOS)

        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS:
            dump_string<Format>(settings, "VkNativeBufferUsageOHOS");
            break;

        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS:
            dump_string<Format>(settings, "VkNativeBufferPropertiesOHOS");
            break;

        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS:
            dump_string<Format>(settings, "VkNativeBufferFormatPropertiesOHOS");
            break;

        case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS:
            dump_string<Format>(settings, "VkImportNativeBufferInfoOHOS");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS:
            dump_string<Format>(settings, "VkMemoryGetNativeBufferInfoOHOS");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS:
            dump_string<Format>(settings, "VkExternalFormatOHOS");
            break;
#endif  // VK_USE_PLATFORM_OHOS

        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
            dump_string<Format>(settings, "VkExternalMemoryAcquireUnmodifiedEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
            dump_string<Format>(settings, "VkRenderPassCreationControlEXT");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkRenderPassCreationFeedbackCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkRenderPassSubpassFeedbackCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG:
            dump_string<Format>(settings, "VkDirectDriverLoadingInfoLUNARG");
            break;

        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
            dump_string<Format>(settings, "VkDirectDriverLoadingListLUNARG");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM:
            dump_string<Format>(settings, "VkTensorDescriptionARM");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkTensorCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM:
            dump_string<Format>(settings, "VkTensorMemoryRequirementsInfoARM");
            break;

        case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM:
            dump_string<Format>(settings, "VkBindTensorMemoryInfoARM");
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM:
            dump_string<Format>(settings, "VkWriteDescriptorSetTensorARM");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkTensorFormatPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceTensorPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
            dump_string<Format>(settings, "VkTensorMemoryBarrierARM");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
            dump_string<Format>(settings, "VkTensorDependencyInfoARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceTensorFeaturesARM");
            break;

        case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM:
            dump_string<Format>(settings, "VkDeviceTensorMemoryRequirementsARM");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM:
            dump_string<Format>(settings, "VkTensorCopyARM");
            break;

        case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM:
            dump_string<Format>(settings, "VkCopyTensorInfoARM");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
            dump_string<Format>(settings, "VkMemoryDedicatedAllocateInfoTensorARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceExternalTensorInfoARM");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkExternalTensorPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkExternalMemoryTensorCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorBufferTensorPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM:
            dump_string<Format>(settings, "VkDescriptorGetTensorInfoARM");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
            dump_string<Format>(settings, "VkTensorCaptureDescriptorDataInfoARM");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
            dump_string<Format>(settings, "VkTensorViewCaptureDescriptorDataInfoARM");
            break;

        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
            dump_string<Format>(settings, "VkFrameBoundaryTensorsARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkPipelineShaderStageModuleIdentifierCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT:
            dump_string<Format>(settings, "VkShaderModuleIdentifierEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceOpticalFlowFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceOpticalFlowPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
            dump_string<Format>(settings, "VkOpticalFlowImageFormatInfoNV");
            break;

        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV:
            dump_string<Format>(settings, "VkOpticalFlowImageFormatPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkOpticalFlowSessionCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
            dump_string<Format>(settings, "VkOpticalFlowSessionCreatePrivateDataInfoNV");
            break;

        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV:
            dump_string<Format>(settings, "VkOpticalFlowExecuteInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceLegacyDitheringFeaturesEXT");
            break;
#if defined(VK_USE_PLATFORM_ANDROID_KHR)

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
            dump_string<Format>(settings, "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
            dump_string<Format>(settings, "VkPhysicalDeviceExternalFormatResolvePropertiesANDROID");
            break;

        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
            dump_string<Format>(settings, "VkAndroidHardwareBufferFormatResolvePropertiesANDROID");
            break;
#endif  // VK_USE_PLATFORM_ANDROID_KHR

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
            dump_string<Format>(settings, "VkPhysicalDeviceAntiLagFeaturesAMD");
            break;

        case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD:
            dump_string<Format>(settings, "VkAntiLagPresentationInfoAMD");
            break;

        case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD:
            dump_string<Format>(settings, "VkAntiLagDataAMD");
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX:
            dump_string<Format>(settings, "VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX:
            dump_string<Format>(settings, "VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX");
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderObjectFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderObjectPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkShaderCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceTilePropertiesFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM:
            dump_string<Format>(settings, "VkTilePropertiesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC:
            dump_string<Format>(settings, "VkPhysicalDeviceAmigoProfilingFeaturesSEC");
            break;

        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
            dump_string<Format>(settings, "VkAmigoProfilingSubmitInfoSEC");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeVectorPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeVectorFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV:
            dump_string<Format>(settings, "VkCooperativeVectorPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV:
            dump_string<Format>(settings, "VkConvertCooperativeVectorMatrixInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkLayerSettingsCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV:
            dump_string<Format>(settings, "VkLatencySleepModeInfoNV");
            break;

        case VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV:
            dump_string<Format>(settings, "VkLatencySleepInfoNV");
            break;

        case VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV:
            dump_string<Format>(settings, "VkSetLatencyMarkerInfoNV");
            break;

        case VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV:
            dump_string<Format>(settings, "VkLatencyTimingsFrameReportNV");
            break;

        case VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV:
            dump_string<Format>(settings, "VkGetLatencyMarkerInfoNV");
            break;

        case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
            dump_string<Format>(settings, "VkLatencySubmissionPresentIdNV");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkSwapchainLatencyCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV:
            dump_string<Format>(settings, "VkOutOfBandQueueTypeInfoNV");
            break;

        case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
            dump_string<Format>(settings, "VkLatencySurfaceCapabilitiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceDataGraphFeaturesARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineConstantARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineResourceInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineCompilerControlCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineShaderModuleCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineSessionCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineSessionBindPointRequirementsInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineSessionBindPointRequirementARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineSessionMemoryRequirementsInfoARM");
            break;

        case VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM:
            dump_string<Format>(settings, "VkBindDataGraphPipelineSessionMemoryInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelinePropertyQueryResultARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineIdentifierCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineDispatchInfoARM");
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkQueueFamilyDataGraphPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphProcessingEngineCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM");
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkQueueFamilyDataGraphProcessingEnginePropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM");
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_TOSA_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkQueueFamilyDataGraphTOSAPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
            dump_string<Format>(settings, "VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDevicePerStageDescriptorSetFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceImageProcessing2FeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceImageProcessing2PropertiesQCOM");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
            dump_string<Format>(settings, "VkSamplerBlockMatchWindowCreateInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceCubicWeightsFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
            dump_string<Format>(settings, "VkSamplerCubicWeightsCreateInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM:
            dump_string<Format>(settings, "VkBlitImageCubicWeightsInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM:
            dump_string<Format>(settings, "VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceCubicClampFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT");
            break;
#if defined(VK_USE_PLATFORM_SCREEN_QNX)

        case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX:
            dump_string<Format>(settings, "VkScreenBufferPropertiesQNX");
            break;

        case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
            dump_string<Format>(settings, "VkScreenBufferFormatPropertiesQNX");
            break;

        case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX:
            dump_string<Format>(settings, "VkImportScreenBufferInfoQNX");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX:
            dump_string<Format>(settings, "VkExternalFormatQNX");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX:
            dump_string<Format>(settings, "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX");
            break;
#endif  // VK_USE_PLATFORM_SCREEN_QNX

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
            dump_string<Format>(settings, "VkPhysicalDeviceLayeredDriverPropertiesMSFT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceTileMemoryHeapPropertiesQCOM");
            break;

        case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
            dump_string<Format>(settings, "VkTileMemoryRequirementsQCOM");
            break;

        case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
            dump_string<Format>(settings, "VkTileMemoryBindInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
            dump_string<Format>(settings, "VkTileMemorySizeInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT:
            dump_string<Format>(settings, "VkDecompressMemoryInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkDisplaySurfaceStereoCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
            dump_string<Format>(settings, "VkDisplayModeStereoPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceRawAccessChainsFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkExternalComputeQueueDeviceCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkExternalComputeQueueCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV:
            dump_string<Format>(settings, "VkExternalComputeQueueDataParamsNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceExternalComputeQueuePropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_ROLLING_BACKING_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkTensorRollingBackingCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_TENSOR_EXPLICIT_TILING_FORMAT_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkTensorExplicitTilingFormatPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderFloat8FeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingValidationFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceClusterAccelerationStructurePropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV:
            dump_string<Format>(settings, "VkClusterAccelerationStructureClustersBottomLevelInputNV");
            break;

        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV:
            dump_string<Format>(settings, "VkClusterAccelerationStructureTriangleClusterInputNV");
            break;

        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV:
            dump_string<Format>(settings, "VkClusterAccelerationStructureMoveObjectsInputNV");
            break;

        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV:
            dump_string<Format>(settings, "VkClusterAccelerationStructureInputInfoNV");
            break;

        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV:
            dump_string<Format>(settings, "VkClusterAccelerationStructureCommandsInfoNV");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureBuildSizesInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
            dump_string<Format>(settings, "VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
            dump_string<Format>(settings, "VkPartitionedAccelerationStructureFlagsNV");
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
            dump_string<Format>(settings, "VkWriteDescriptorSetPartitionedAccelerationStructureNV");
            break;

        case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV:
            dump_string<Format>(settings, "VkPartitionedAccelerationStructureInstancesInputNV");
            break;

        case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV:
            dump_string<Format>(settings, "VkBuildPartitionedAccelerationStructureInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT:
            dump_string<Format>(settings, "VkGeneratedCommandsMemoryRequirementsInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT:
            dump_string<Format>(settings, "VkIndirectExecutionSetPipelineInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT:
            dump_string<Format>(settings, "VkIndirectExecutionSetShaderLayoutInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT:
            dump_string<Format>(settings, "VkIndirectExecutionSetShaderInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkIndirectExecutionSetCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT:
            dump_string<Format>(settings, "VkGeneratedCommandsInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT:
            dump_string<Format>(settings, "VkWriteIndirectExecutionSetPipelineEXT");
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT:
            dump_string<Format>(settings, "VkIndirectCommandsLayoutTokenEXT");
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkIndirectCommandsLayoutCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT:
            dump_string<Format>(settings, "VkGeneratedCommandsPipelineInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
            dump_string<Format>(settings, "VkGeneratedCommandsShaderInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT:
            dump_string<Format>(settings, "VkWriteIndirectExecutionSetShaderEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
            dump_string<Format>(settings, "VkPhysicalDeviceImageAlignmentControlFeaturesMESA");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
            dump_string<Format>(settings, "VkPhysicalDeviceImageAlignmentControlPropertiesMESA");
            break;

        case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
            dump_string<Format>(settings, "VkImageAlignmentControlCreateInfoMESA");
            break;

        case VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV:
            dump_string<Format>(settings, "VkPushConstantBankInfoNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDevicePushConstantBankFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDevicePushConstantBankPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceDepthClampControlFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkPipelineViewportDepthClampControlCreateInfoEXT");
            break;
#if defined(VK_USE_PLATFORM_OHOS)

        case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS:
            dump_string<Format>(settings, "VkSurfaceCreateInfoOHOS");
            break;
#endif  // VK_USE_PLATFORM_OHOS

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
            dump_string<Format>(settings, "VkPhysicalDeviceHdrVividFeaturesHUAWEI");
            break;

        case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI:
            dump_string<Format>(settings, "VkHdrVividDynamicMetadataHUAWEI");
            break;

        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV:
            dump_string<Format>(settings, "VkCooperativeMatrixFlexibleDimensionsPropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrix2FeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrix2PropertiesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM");
            break;
#if defined(VK_USE_PLATFORM_METAL_EXT)

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT:
            dump_string<Format>(settings, "VkImportMemoryMetalHandleInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkMemoryMetalHandlePropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT:
            dump_string<Format>(settings, "VkMemoryGetMetalHandleInfoEXT");
            break;
#endif  // VK_USE_PLATFORM_METAL_EXT

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDevicePerformanceCountersByRegionFeaturesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkPhysicalDevicePerformanceCountersByRegionPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM:
            dump_string<Format>(settings, "VkPerformanceCounterARM");
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM:
            dump_string<Format>(settings, "VkPerformanceCounterDescriptionARM");
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM:
            dump_string<Format>(settings, "VkRenderPassPerformanceCountersByRegionBeginInfoARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderInstrumentationFeaturesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderInstrumentationPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkShaderInstrumentationCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM:
            dump_string<Format>(settings, "VkShaderInstrumentationMetricDescriptionARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceFormatPackFeaturesARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE:
            dump_string<Format>(settings, "VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE");
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE:
            dump_string<Format>(settings, "VkPipelineFragmentDensityMapLayeredCreateInfoVALVE");
            break;

        case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
            dump_string<Format>(settings, "VkSetPresentConfigNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDevicePresentMeteringFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT:
            dump_string<Format>(settings, "VkSwapchainFlagsSurfaceCapabilitiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShader64BitIndexingFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceCustomResolveFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT:
            dump_string<Format>(settings, "VkBeginCustomResolveInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT:
            dump_string<Format>(settings, "VkCustomResolveCreateInfoEXT");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM:
            dump_string<Format>(settings, "VkDataGraphPipelineBuiltinModelCreateInfoQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM:
            dump_string<Format>(settings, "VkPhysicalDeviceDataGraphModelFeaturesQCOM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM");
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkQueueFamilyDataGraphOpticalFlowPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineOpticalFlowCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM:
            dump_string<Format>(settings, "VkDataGraphOpticalFlowImageFormatPropertiesARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphOpticalFlowImageFormatInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineOpticalFlowDispatchInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineResourceInfoImageLayoutARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineSingleNodeConnectionARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineSingleNodeCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderLongVectorFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderLongVectorPropertiesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
            dump_string<Format>(settings, "VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV:
            dump_string<Format>(settings, "VkComputeOccupancyPriorityParametersNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT");
            break;
#if defined(VK_USE_PLATFORM_UBM_SEC)

        case VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC:
            dump_string<Format>(settings, "VkUbmSurfaceCreateInfoSEC");
            break;
#endif  // VK_USE_PLATFORM_UBM_SEC

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OCP_MICROSCALING_TYPES_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE:
            dump_string<Format>(settings, "VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE");
            break;

        case VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC:
            dump_string<Format>(settings, "VkThrottleHintSubmitInfoSEC");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC:
            dump_string<Format>(settings, "VkPhysicalDeviceThrottleHintFeaturesSEC");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM:
            dump_string<Format>(settings, "VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineNeuralStatisticsCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM:
            dump_string<Format>(settings, "VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV:
            dump_string<Format>(settings, "VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureGeometryTrianglesDataKHR");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureGeometryAabbsDataKHR");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureGeometryInstancesDataKHR");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureGeometryKHR");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureBuildGeometryInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
            dump_string<Format>(settings, "VkWriteDescriptorSetAccelerationStructureKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceAccelerationStructureFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceAccelerationStructurePropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureDeviceAddressInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR:
            dump_string<Format>(settings, "VkAccelerationStructureVersionInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR:
            dump_string<Format>(settings, "VkCopyAccelerationStructureToMemoryInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR:
            dump_string<Format>(settings, "VkCopyMemoryToAccelerationStructureInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR:
            dump_string<Format>(settings, "VkCopyAccelerationStructureInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkRayTracingShaderGroupCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkRayTracingPipelineInterfaceCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
            dump_string<Format>(settings, "VkRayTracingPipelineCreateInfoKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingPipelineFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceRayTracingPipelinePropertiesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
            dump_string<Format>(settings, "VkPhysicalDeviceRayQueryFeaturesKHR");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMeshShaderFeaturesEXT");
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
            dump_string<Format>(settings, "VkPhysicalDeviceMeshShaderPropertiesEXT");
            break;

        default:
            dump_string<Format>(settings, "NULL");
            break;
    }
    dump_end<Format>(settings, OutputConstruct::value, indents);
}

template <ApiDumpFormat Format>
void dump_pNext_trampoline(const void* object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents) {
    if (object == NULL) {
        if constexpr (Format == ApiDumpFormat::Html || Format == ApiDumpFormat::Json) {
            dump_nullptr<Format>(settings, type_name, var_name, indents);
        }
        return;
    }
    VkBaseInStructure base_struct{};
    memcpy(&base_struct, object, sizeof(VkBaseInStructure));
    switch (base_struct.sType) {
        case VK_STRUCTURE_TYPE_APPLICATION_INFO:
            dump_VkApplicationInfo<Format>(*reinterpret_cast<const VkApplicationInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkApplicationInfo*" : "VkApplicationInfo"), "pNext", indents, reinterpret_cast<const VkApplicationInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:
            dump_VkInstanceCreateInfo<Format>(*reinterpret_cast<const VkInstanceCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkInstanceCreateInfo*" : "VkInstanceCreateInfo"), "pNext", indents, reinterpret_cast<const VkInstanceCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:
            dump_VkDeviceQueueCreateInfo<Format>(*reinterpret_cast<const VkDeviceQueueCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceQueueCreateInfo*" : "VkDeviceQueueCreateInfo"), "pNext", indents, reinterpret_cast<const VkDeviceQueueCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
            dump_VkDeviceCreateInfo<Format>(*reinterpret_cast<const VkDeviceCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceCreateInfo*" : "VkDeviceCreateInfo"), "pNext", indents, reinterpret_cast<const VkDeviceCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SUBMIT_INFO:
            dump_VkSubmitInfo<Format>(*reinterpret_cast<const VkSubmitInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubmitInfo*" : "VkSubmitInfo"), "pNext", indents, reinterpret_cast<const VkSubmitInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:
            dump_VkMappedMemoryRange<Format>(*reinterpret_cast<const VkMappedMemoryRange*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMappedMemoryRange*" : "VkMappedMemoryRange"), "pNext", indents, reinterpret_cast<const VkMappedMemoryRange*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
            dump_VkMemoryAllocateInfo<Format>(*reinterpret_cast<const VkMemoryAllocateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryAllocateInfo*" : "VkMemoryAllocateInfo"), "pNext", indents, reinterpret_cast<const VkMemoryAllocateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
            dump_VkBindSparseInfo<Format>(*reinterpret_cast<const VkBindSparseInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindSparseInfo*" : "VkBindSparseInfo"), "pNext", indents, reinterpret_cast<const VkBindSparseInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:
            dump_VkFenceCreateInfo<Format>(*reinterpret_cast<const VkFenceCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFenceCreateInfo*" : "VkFenceCreateInfo"), "pNext", indents, reinterpret_cast<const VkFenceCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
            dump_VkSemaphoreCreateInfo<Format>(*reinterpret_cast<const VkSemaphoreCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreCreateInfo*" : "VkSemaphoreCreateInfo"), "pNext", indents, reinterpret_cast<const VkSemaphoreCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
            dump_VkQueryPoolCreateInfo<Format>(*reinterpret_cast<const VkQueryPoolCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueryPoolCreateInfo*" : "VkQueryPoolCreateInfo"), "pNext", indents, reinterpret_cast<const VkQueryPoolCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
            dump_VkBufferCreateInfo<Format>(*reinterpret_cast<const VkBufferCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCreateInfo*" : "VkBufferCreateInfo"), "pNext", indents, reinterpret_cast<const VkBufferCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
            dump_VkImageCreateInfo<Format>(*reinterpret_cast<const VkImageCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageCreateInfo*" : "VkImageCreateInfo"), "pNext", indents, reinterpret_cast<const VkImageCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
            dump_VkImageViewCreateInfo<Format>(*reinterpret_cast<const VkImageViewCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewCreateInfo*" : "VkImageViewCreateInfo"), "pNext", indents, reinterpret_cast<const VkImageViewCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:
            dump_VkCommandPoolCreateInfo<Format>(*reinterpret_cast<const VkCommandPoolCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandPoolCreateInfo*" : "VkCommandPoolCreateInfo"), "pNext", indents, reinterpret_cast<const VkCommandPoolCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:
            dump_VkCommandBufferAllocateInfo<Format>(*reinterpret_cast<const VkCommandBufferAllocateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferAllocateInfo*" : "VkCommandBufferAllocateInfo"), "pNext", indents, reinterpret_cast<const VkCommandBufferAllocateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:
            dump_VkCommandBufferInheritanceInfo<Format>(*reinterpret_cast<const VkCommandBufferInheritanceInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceInfo*" : "VkCommandBufferInheritanceInfo"), "pNext", indents, reinterpret_cast<const VkCommandBufferInheritanceInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
            dump_VkCommandBufferBeginInfo<Format>(*reinterpret_cast<const VkCommandBufferBeginInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferBeginInfo*" : "VkCommandBufferBeginInfo"), "pNext", indents, reinterpret_cast<const VkCommandBufferBeginInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
            dump_VkBufferMemoryBarrier<Format>(*reinterpret_cast<const VkBufferMemoryBarrier*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferMemoryBarrier*" : "VkBufferMemoryBarrier"), "pNext", indents, reinterpret_cast<const VkBufferMemoryBarrier*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
            dump_VkImageMemoryBarrier<Format>(*reinterpret_cast<const VkImageMemoryBarrier*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageMemoryBarrier*" : "VkImageMemoryBarrier"), "pNext", indents, reinterpret_cast<const VkImageMemoryBarrier*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
            dump_VkMemoryBarrier<Format>(*reinterpret_cast<const VkMemoryBarrier*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryBarrier*" : "VkMemoryBarrier"), "pNext", indents, reinterpret_cast<const VkMemoryBarrier*>(object));
            break;

        case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:
            dump_VkEventCreateInfo<Format>(*reinterpret_cast<const VkEventCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkEventCreateInfo*" : "VkEventCreateInfo"), "pNext", indents, reinterpret_cast<const VkEventCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
            dump_VkBufferViewCreateInfo<Format>(*reinterpret_cast<const VkBufferViewCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferViewCreateInfo*" : "VkBufferViewCreateInfo"), "pNext", indents, reinterpret_cast<const VkBufferViewCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
            dump_VkShaderModuleCreateInfo<Format>(*reinterpret_cast<const VkShaderModuleCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderModuleCreateInfo*" : "VkShaderModuleCreateInfo"), "pNext", indents, reinterpret_cast<const VkShaderModuleCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:
            dump_VkPipelineCacheCreateInfo<Format>(*reinterpret_cast<const VkPipelineCacheCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCacheCreateInfo*" : "VkPipelineCacheCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineCacheCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
            dump_VkPipelineShaderStageCreateInfo<Format>(*reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineShaderStageCreateInfo*" : "VkPipelineShaderStageCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
            dump_VkComputePipelineCreateInfo<Format>(*reinterpret_cast<const VkComputePipelineCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkComputePipelineCreateInfo*" : "VkComputePipelineCreateInfo"), "pNext", indents, reinterpret_cast<const VkComputePipelineCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
            dump_VkPipelineLayoutCreateInfo<Format>(*reinterpret_cast<const VkPipelineLayoutCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineLayoutCreateInfo*" : "VkPipelineLayoutCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineLayoutCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
            dump_VkSamplerCreateInfo<Format>(*reinterpret_cast<const VkSamplerCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerCreateInfo*" : "VkSamplerCreateInfo"), "pNext", indents, reinterpret_cast<const VkSamplerCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
            dump_VkCopyDescriptorSet<Format>(*reinterpret_cast<const VkCopyDescriptorSet*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyDescriptorSet*" : "VkCopyDescriptorSet"), "pNext", indents, reinterpret_cast<const VkCopyDescriptorSet*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:
            dump_VkDescriptorPoolCreateInfo<Format>(*reinterpret_cast<const VkDescriptorPoolCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorPoolCreateInfo*" : "VkDescriptorPoolCreateInfo"), "pNext", indents, reinterpret_cast<const VkDescriptorPoolCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
            dump_VkDescriptorSetAllocateInfo<Format>(*reinterpret_cast<const VkDescriptorSetAllocateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetAllocateInfo*" : "VkDescriptorSetAllocateInfo"), "pNext", indents, reinterpret_cast<const VkDescriptorSetAllocateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
            dump_VkDescriptorSetLayoutCreateInfo<Format>(*reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetLayoutCreateInfo*" : "VkDescriptorSetLayoutCreateInfo"), "pNext", indents, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
            dump_VkWriteDescriptorSet<Format>(*reinterpret_cast<const VkWriteDescriptorSet*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSet*" : "VkWriteDescriptorSet"), "pNext", indents, reinterpret_cast<const VkWriteDescriptorSet*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
            dump_VkPipelineColorBlendStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineColorBlendStateCreateInfo*" : "VkPipelineColorBlendStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
            dump_VkPipelineDepthStencilStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineDepthStencilStateCreateInfo*" : "VkPipelineDepthStencilStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
            dump_VkPipelineDynamicStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineDynamicStateCreateInfo*" : "VkPipelineDynamicStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
            dump_VkPipelineInputAssemblyStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineInputAssemblyStateCreateInfo*" : "VkPipelineInputAssemblyStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
            dump_VkPipelineMultisampleStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineMultisampleStateCreateInfo*" : "VkPipelineMultisampleStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
            dump_VkPipelineRasterizationStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationStateCreateInfo*" : "VkPipelineRasterizationStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
            dump_VkPipelineTessellationStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineTessellationStateCreateInfo*" : "VkPipelineTessellationStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
            dump_VkPipelineVertexInputStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineVertexInputStateCreateInfo*" : "VkPipelineVertexInputStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
            dump_VkPipelineViewportStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportStateCreateInfo*" : "VkPipelineViewportStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
            dump_VkGraphicsPipelineCreateInfo<Format>(*reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGraphicsPipelineCreateInfo*" : "VkGraphicsPipelineCreateInfo"), "pNext", indents, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
            dump_VkFramebufferCreateInfo<Format>(*reinterpret_cast<const VkFramebufferCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFramebufferCreateInfo*" : "VkFramebufferCreateInfo"), "pNext", indents, reinterpret_cast<const VkFramebufferCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
            dump_VkRenderPassCreateInfo<Format>(*reinterpret_cast<const VkRenderPassCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassCreateInfo*" : "VkRenderPassCreateInfo"), "pNext", indents, reinterpret_cast<const VkRenderPassCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:
            dump_VkRenderPassBeginInfo<Format>(*reinterpret_cast<const VkRenderPassBeginInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassBeginInfo*" : "VkRenderPassBeginInfo"), "pNext", indents, reinterpret_cast<const VkRenderPassBeginInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO:
            dump_VkBindBufferMemoryInfo<Format>(*reinterpret_cast<const VkBindBufferMemoryInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindBufferMemoryInfo*" : "VkBindBufferMemoryInfo"), "pNext", indents, reinterpret_cast<const VkBindBufferMemoryInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO:
            dump_VkBindImageMemoryInfo<Format>(*reinterpret_cast<const VkBindImageMemoryInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindImageMemoryInfo*" : "VkBindImageMemoryInfo"), "pNext", indents, reinterpret_cast<const VkBindImageMemoryInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
            dump_VkMemoryDedicatedRequirements<Format>(*reinterpret_cast<const VkMemoryDedicatedRequirements*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryDedicatedRequirements*" : "VkMemoryDedicatedRequirements"), "pNext", indents, reinterpret_cast<const VkMemoryDedicatedRequirements*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
            dump_VkMemoryDedicatedAllocateInfo<Format>(*reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryDedicatedAllocateInfo*" : "VkMemoryDedicatedAllocateInfo"), "pNext", indents, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
            dump_VkMemoryAllocateFlagsInfo<Format>(*reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryAllocateFlagsInfo*" : "VkMemoryAllocateFlagsInfo"), "pNext", indents, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
            dump_VkDeviceGroupCommandBufferBeginInfo<Format>(*reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupCommandBufferBeginInfo*" : "VkDeviceGroupCommandBufferBeginInfo"), "pNext", indents, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
            dump_VkDeviceGroupSubmitInfo<Format>(*reinterpret_cast<const VkDeviceGroupSubmitInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupSubmitInfo*" : "VkDeviceGroupSubmitInfo"), "pNext", indents, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
            dump_VkDeviceGroupBindSparseInfo<Format>(*reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupBindSparseInfo*" : "VkDeviceGroupBindSparseInfo"), "pNext", indents, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
            dump_VkBindBufferMemoryDeviceGroupInfo<Format>(*reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindBufferMemoryDeviceGroupInfo*" : "VkBindBufferMemoryDeviceGroupInfo"), "pNext", indents, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
            dump_VkBindImageMemoryDeviceGroupInfo<Format>(*reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindImageMemoryDeviceGroupInfo*" : "VkBindImageMemoryDeviceGroupInfo"), "pNext", indents, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES:
            dump_VkPhysicalDeviceGroupProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceGroupProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceGroupProperties*" : "VkPhysicalDeviceGroupProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceGroupProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
            dump_VkDeviceGroupDeviceCreateInfo<Format>(*reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupDeviceCreateInfo*" : "VkDeviceGroupDeviceCreateInfo"), "pNext", indents, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2:
            dump_VkBufferMemoryRequirementsInfo2<Format>(*reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferMemoryRequirementsInfo2*" : "VkBufferMemoryRequirementsInfo2"), "pNext", indents, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:
            dump_VkImageMemoryRequirementsInfo2<Format>(*reinterpret_cast<const VkImageMemoryRequirementsInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageMemoryRequirementsInfo2*" : "VkImageMemoryRequirementsInfo2"), "pNext", indents, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2:
            dump_VkImageSparseMemoryRequirementsInfo2<Format>(*reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageSparseMemoryRequirementsInfo2*" : "VkImageSparseMemoryRequirementsInfo2"), "pNext", indents, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2:
            dump_VkMemoryRequirements2<Format>(*reinterpret_cast<const VkMemoryRequirements2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryRequirements2*" : "VkMemoryRequirements2"), "pNext", indents, reinterpret_cast<const VkMemoryRequirements2*>(object));
            break;

        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2:
            dump_VkSparseImageMemoryRequirements2<Format>(*reinterpret_cast<const VkSparseImageMemoryRequirements2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSparseImageMemoryRequirements2*" : "VkSparseImageMemoryRequirements2"), "pNext", indents, reinterpret_cast<const VkSparseImageMemoryRequirements2*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
            dump_VkPhysicalDeviceFeatures2<Format>(*reinterpret_cast<const VkPhysicalDeviceFeatures2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFeatures2*" : "VkPhysicalDeviceFeatures2"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
            dump_VkPhysicalDeviceProperties2<Format>(*reinterpret_cast<const VkPhysicalDeviceProperties2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceProperties2*" : "VkPhysicalDeviceProperties2"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceProperties2*>(object));
            break;

        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2:
            dump_VkFormatProperties2<Format>(*reinterpret_cast<const VkFormatProperties2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFormatProperties2*" : "VkFormatProperties2"), "pNext", indents, reinterpret_cast<const VkFormatProperties2*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2:
            dump_VkImageFormatProperties2<Format>(*reinterpret_cast<const VkImageFormatProperties2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageFormatProperties2*" : "VkImageFormatProperties2"), "pNext", indents, reinterpret_cast<const VkImageFormatProperties2*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2:
            dump_VkPhysicalDeviceImageFormatInfo2<Format>(*reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageFormatInfo2*" : "VkPhysicalDeviceImageFormatInfo2"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2:
            dump_VkQueueFamilyProperties2<Format>(*reinterpret_cast<const VkQueueFamilyProperties2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyProperties2*" : "VkQueueFamilyProperties2"), "pNext", indents, reinterpret_cast<const VkQueueFamilyProperties2*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2:
            dump_VkPhysicalDeviceMemoryProperties2<Format>(*reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMemoryProperties2*" : "VkPhysicalDeviceMemoryProperties2"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>(object));
            break;

        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2:
            dump_VkSparseImageFormatProperties2<Format>(*reinterpret_cast<const VkSparseImageFormatProperties2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSparseImageFormatProperties2*" : "VkSparseImageFormatProperties2"), "pNext", indents, reinterpret_cast<const VkSparseImageFormatProperties2*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2:
            dump_VkPhysicalDeviceSparseImageFormatInfo2<Format>(*reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSparseImageFormatInfo2*" : "VkPhysicalDeviceSparseImageFormatInfo2"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
            dump_VkImageViewUsageCreateInfo<Format>(*reinterpret_cast<const VkImageViewUsageCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewUsageCreateInfo*" : "VkImageViewUsageCreateInfo"), "pNext", indents, reinterpret_cast<const VkImageViewUsageCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
            dump_VkPhysicalDeviceProtectedMemoryFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceProtectedMemoryFeatures*" : "VkPhysicalDeviceProtectedMemoryFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
            dump_VkPhysicalDeviceProtectedMemoryProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceProtectedMemoryProperties*" : "VkPhysicalDeviceProtectedMemoryProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2:
            dump_VkDeviceQueueInfo2<Format>(*reinterpret_cast<const VkDeviceQueueInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceQueueInfo2*" : "VkDeviceQueueInfo2"), "pNext", indents, reinterpret_cast<const VkDeviceQueueInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
            dump_VkProtectedSubmitInfo<Format>(*reinterpret_cast<const VkProtectedSubmitInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkProtectedSubmitInfo*" : "VkProtectedSubmitInfo"), "pNext", indents, reinterpret_cast<const VkProtectedSubmitInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
            dump_VkBindImagePlaneMemoryInfo<Format>(*reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindImagePlaneMemoryInfo*" : "VkBindImagePlaneMemoryInfo"), "pNext", indents, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
            dump_VkImagePlaneMemoryRequirementsInfo<Format>(*reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImagePlaneMemoryRequirementsInfo*" : "VkImagePlaneMemoryRequirementsInfo"), "pNext", indents, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
            dump_VkPhysicalDeviceExternalImageFormatInfo<Format>(*reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalImageFormatInfo*" : "VkPhysicalDeviceExternalImageFormatInfo"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
            dump_VkExternalImageFormatProperties<Format>(*reinterpret_cast<const VkExternalImageFormatProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalImageFormatProperties*" : "VkExternalImageFormatProperties"), "pNext", indents, reinterpret_cast<const VkExternalImageFormatProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO:
            dump_VkPhysicalDeviceExternalBufferInfo<Format>(*reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalBufferInfo*" : "VkPhysicalDeviceExternalBufferInfo"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES:
            dump_VkExternalBufferProperties<Format>(*reinterpret_cast<const VkExternalBufferProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalBufferProperties*" : "VkExternalBufferProperties"), "pNext", indents, reinterpret_cast<const VkExternalBufferProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
            dump_VkPhysicalDeviceIDProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceIDProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceIDProperties*" : "VkPhysicalDeviceIDProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
            dump_VkExternalMemoryImageCreateInfo<Format>(*reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalMemoryImageCreateInfo*" : "VkExternalMemoryImageCreateInfo"), "pNext", indents, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
            dump_VkExternalMemoryBufferCreateInfo<Format>(*reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalMemoryBufferCreateInfo*" : "VkExternalMemoryBufferCreateInfo"), "pNext", indents, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
            dump_VkExportMemoryAllocateInfo<Format>(*reinterpret_cast<const VkExportMemoryAllocateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMemoryAllocateInfo*" : "VkExportMemoryAllocateInfo"), "pNext", indents, reinterpret_cast<const VkExportMemoryAllocateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO:
            dump_VkPhysicalDeviceExternalFenceInfo<Format>(*reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalFenceInfo*" : "VkPhysicalDeviceExternalFenceInfo"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES:
            dump_VkExternalFenceProperties<Format>(*reinterpret_cast<const VkExternalFenceProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalFenceProperties*" : "VkExternalFenceProperties"), "pNext", indents, reinterpret_cast<const VkExternalFenceProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
            dump_VkExportFenceCreateInfo<Format>(*reinterpret_cast<const VkExportFenceCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportFenceCreateInfo*" : "VkExportFenceCreateInfo"), "pNext", indents, reinterpret_cast<const VkExportFenceCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
            dump_VkExportSemaphoreCreateInfo<Format>(*reinterpret_cast<const VkExportSemaphoreCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportSemaphoreCreateInfo*" : "VkExportSemaphoreCreateInfo"), "pNext", indents, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO:
            dump_VkPhysicalDeviceExternalSemaphoreInfo<Format>(*reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalSemaphoreInfo*" : "VkPhysicalDeviceExternalSemaphoreInfo"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES:
            dump_VkExternalSemaphoreProperties<Format>(*reinterpret_cast<const VkExternalSemaphoreProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalSemaphoreProperties*" : "VkExternalSemaphoreProperties"), "pNext", indents, reinterpret_cast<const VkExternalSemaphoreProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
            dump_VkPhysicalDeviceSubgroupProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubgroupProperties*" : "VkPhysicalDeviceSubgroupProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
            dump_VkPhysicalDevice16BitStorageFeatures<Format>(*reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevice16BitStorageFeatures*" : "VkPhysicalDevice16BitStorageFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
            dump_VkPhysicalDeviceVariablePointersFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVariablePointersFeatures*" : "VkPhysicalDeviceVariablePointersFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO:
            dump_VkDescriptorUpdateTemplateCreateInfo<Format>(*reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorUpdateTemplateCreateInfo*" : "VkDescriptorUpdateTemplateCreateInfo"), "pNext", indents, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
            dump_VkPhysicalDeviceMaintenance3Properties<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance3Properties*" : "VkPhysicalDeviceMaintenance3Properties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT:
            dump_VkDescriptorSetLayoutSupport<Format>(*reinterpret_cast<const VkDescriptorSetLayoutSupport*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetLayoutSupport*" : "VkDescriptorSetLayoutSupport"), "pNext", indents, reinterpret_cast<const VkDescriptorSetLayoutSupport*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO:
            dump_VkSamplerYcbcrConversionCreateInfo<Format>(*reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerYcbcrConversionCreateInfo*" : "VkSamplerYcbcrConversionCreateInfo"), "pNext", indents, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
            dump_VkSamplerYcbcrConversionInfo<Format>(*reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerYcbcrConversionInfo*" : "VkSamplerYcbcrConversionInfo"), "pNext", indents, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
            dump_VkPhysicalDeviceSamplerYcbcrConversionFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSamplerYcbcrConversionFeatures*" : "VkPhysicalDeviceSamplerYcbcrConversionFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
            dump_VkSamplerYcbcrConversionImageFormatProperties<Format>(*reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerYcbcrConversionImageFormatProperties*" : "VkSamplerYcbcrConversionImageFormatProperties"), "pNext", indents, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
            dump_VkDeviceGroupRenderPassBeginInfo<Format>(*reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupRenderPassBeginInfo*" : "VkDeviceGroupRenderPassBeginInfo"), "pNext", indents, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
            dump_VkPhysicalDevicePointClippingProperties<Format>(*reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePointClippingProperties*" : "VkPhysicalDevicePointClippingProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
            dump_VkRenderPassInputAttachmentAspectCreateInfo<Format>(*reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassInputAttachmentAspectCreateInfo*" : "VkRenderPassInputAttachmentAspectCreateInfo"), "pNext", indents, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
            dump_VkPipelineTessellationDomainOriginStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineTessellationDomainOriginStateCreateInfo*" : "VkPipelineTessellationDomainOriginStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
            dump_VkRenderPassMultiviewCreateInfo<Format>(*reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassMultiviewCreateInfo*" : "VkRenderPassMultiviewCreateInfo"), "pNext", indents, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
            dump_VkPhysicalDeviceMultiviewFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiviewFeatures*" : "VkPhysicalDeviceMultiviewFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
            dump_VkPhysicalDeviceMultiviewProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiviewProperties*" : "VkPhysicalDeviceMultiviewProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
            dump_VkPhysicalDeviceShaderDrawParametersFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderDrawParametersFeatures*" : "VkPhysicalDeviceShaderDrawParametersFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
            dump_VkPhysicalDeviceDriverProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDriverProperties*" : "VkPhysicalDeviceDriverProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
            dump_VkPhysicalDeviceVulkan11Features<Format>(*reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan11Features*" : "VkPhysicalDeviceVulkan11Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
            dump_VkPhysicalDeviceVulkan11Properties<Format>(*reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan11Properties*" : "VkPhysicalDeviceVulkan11Properties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
            dump_VkPhysicalDeviceVulkan12Features<Format>(*reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan12Features*" : "VkPhysicalDeviceVulkan12Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
            dump_VkPhysicalDeviceVulkan12Properties<Format>(*reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan12Properties*" : "VkPhysicalDeviceVulkan12Properties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
            dump_VkImageFormatListCreateInfo<Format>(*reinterpret_cast<const VkImageFormatListCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageFormatListCreateInfo*" : "VkImageFormatListCreateInfo"), "pNext", indents, reinterpret_cast<const VkImageFormatListCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
            dump_VkPhysicalDeviceVulkanMemoryModelFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkanMemoryModelFeatures*" : "VkPhysicalDeviceVulkanMemoryModelFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
            dump_VkPhysicalDeviceHostQueryResetFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceHostQueryResetFeatures*" : "VkPhysicalDeviceHostQueryResetFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
            dump_VkPhysicalDeviceTimelineSemaphoreFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTimelineSemaphoreFeatures*" : "VkPhysicalDeviceTimelineSemaphoreFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
            dump_VkPhysicalDeviceTimelineSemaphoreProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTimelineSemaphoreProperties*" : "VkPhysicalDeviceTimelineSemaphoreProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
            dump_VkSemaphoreTypeCreateInfo<Format>(*reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreTypeCreateInfo*" : "VkSemaphoreTypeCreateInfo"), "pNext", indents, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
            dump_VkTimelineSemaphoreSubmitInfo<Format>(*reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTimelineSemaphoreSubmitInfo*" : "VkTimelineSemaphoreSubmitInfo"), "pNext", indents, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO:
            dump_VkSemaphoreWaitInfo<Format>(*reinterpret_cast<const VkSemaphoreWaitInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreWaitInfo*" : "VkSemaphoreWaitInfo"), "pNext", indents, reinterpret_cast<const VkSemaphoreWaitInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO:
            dump_VkSemaphoreSignalInfo<Format>(*reinterpret_cast<const VkSemaphoreSignalInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreSignalInfo*" : "VkSemaphoreSignalInfo"), "pNext", indents, reinterpret_cast<const VkSemaphoreSignalInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
            dump_VkPhysicalDeviceBufferDeviceAddressFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceBufferDeviceAddressFeatures*" : "VkPhysicalDeviceBufferDeviceAddressFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO:
            dump_VkBufferDeviceAddressInfo<Format>(*reinterpret_cast<const VkBufferDeviceAddressInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferDeviceAddressInfo*" : "VkBufferDeviceAddressInfo"), "pNext", indents, reinterpret_cast<const VkBufferDeviceAddressInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
            dump_VkBufferOpaqueCaptureAddressCreateInfo<Format>(*reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferOpaqueCaptureAddressCreateInfo*" : "VkBufferOpaqueCaptureAddressCreateInfo"), "pNext", indents, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
            dump_VkMemoryOpaqueCaptureAddressAllocateInfo<Format>(*reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryOpaqueCaptureAddressAllocateInfo*" : "VkMemoryOpaqueCaptureAddressAllocateInfo"), "pNext", indents, reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO:
            dump_VkDeviceMemoryOpaqueCaptureAddressInfo<Format>(*reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceMemoryOpaqueCaptureAddressInfo*" : "VkDeviceMemoryOpaqueCaptureAddressInfo"), "pNext", indents, reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
            dump_VkPhysicalDevice8BitStorageFeatures<Format>(*reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevice8BitStorageFeatures*" : "VkPhysicalDevice8BitStorageFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
            dump_VkPhysicalDeviceShaderAtomicInt64Features<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderAtomicInt64Features*" : "VkPhysicalDeviceShaderAtomicInt64Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
            dump_VkPhysicalDeviceShaderFloat16Int8Features<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderFloat16Int8Features*" : "VkPhysicalDeviceShaderFloat16Int8Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
            dump_VkPhysicalDeviceFloatControlsProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFloatControlsProperties*" : "VkPhysicalDeviceFloatControlsProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
            dump_VkDescriptorSetLayoutBindingFlagsCreateInfo<Format>(*reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetLayoutBindingFlagsCreateInfo*" : "VkDescriptorSetLayoutBindingFlagsCreateInfo"), "pNext", indents, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
            dump_VkPhysicalDeviceDescriptorIndexingFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorIndexingFeatures*" : "VkPhysicalDeviceDescriptorIndexingFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
            dump_VkPhysicalDeviceDescriptorIndexingProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorIndexingProperties*" : "VkPhysicalDeviceDescriptorIndexingProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
            dump_VkDescriptorSetVariableDescriptorCountAllocateInfo<Format>(*reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetVariableDescriptorCountAllocateInfo*" : "VkDescriptorSetVariableDescriptorCountAllocateInfo"), "pNext", indents, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
            dump_VkDescriptorSetVariableDescriptorCountLayoutSupport<Format>(*reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetVariableDescriptorCountLayoutSupport*" : "VkDescriptorSetVariableDescriptorCountLayoutSupport"), "pNext", indents, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
            dump_VkPhysicalDeviceScalarBlockLayoutFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceScalarBlockLayoutFeatures*" : "VkPhysicalDeviceScalarBlockLayoutFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
            dump_VkSamplerReductionModeCreateInfo<Format>(*reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerReductionModeCreateInfo*" : "VkSamplerReductionModeCreateInfo"), "pNext", indents, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
            dump_VkPhysicalDeviceSamplerFilterMinmaxProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSamplerFilterMinmaxProperties*" : "VkPhysicalDeviceSamplerFilterMinmaxProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
            dump_VkPhysicalDeviceUniformBufferStandardLayoutFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceUniformBufferStandardLayoutFeatures*" : "VkPhysicalDeviceUniformBufferStandardLayoutFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
            dump_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*" : "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2:
            dump_VkAttachmentDescription2<Format>(*reinterpret_cast<const VkAttachmentDescription2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentDescription2*" : "VkAttachmentDescription2"), "pNext", indents, reinterpret_cast<const VkAttachmentDescription2*>(object));
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2:
            dump_VkAttachmentReference2<Format>(*reinterpret_cast<const VkAttachmentReference2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentReference2*" : "VkAttachmentReference2"), "pNext", indents, reinterpret_cast<const VkAttachmentReference2*>(object));
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2:
            dump_VkSubpassDescription2<Format>(*reinterpret_cast<const VkSubpassDescription2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassDescription2*" : "VkSubpassDescription2"), "pNext", indents, reinterpret_cast<const VkSubpassDescription2*>(object));
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2:
            dump_VkSubpassDependency2<Format>(*reinterpret_cast<const VkSubpassDependency2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassDependency2*" : "VkSubpassDependency2"), "pNext", indents, reinterpret_cast<const VkSubpassDependency2*>(object));
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO:
            dump_VkSubpassBeginInfo<Format>(*reinterpret_cast<const VkSubpassBeginInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassBeginInfo*" : "VkSubpassBeginInfo"), "pNext", indents, reinterpret_cast<const VkSubpassBeginInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_END_INFO:
            dump_VkSubpassEndInfo<Format>(*reinterpret_cast<const VkSubpassEndInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassEndInfo*" : "VkSubpassEndInfo"), "pNext", indents, reinterpret_cast<const VkSubpassEndInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
            dump_VkRenderPassCreateInfo2<Format>(*reinterpret_cast<const VkRenderPassCreateInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassCreateInfo2*" : "VkRenderPassCreateInfo2"), "pNext", indents, reinterpret_cast<const VkRenderPassCreateInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
            dump_VkSubpassDescriptionDepthStencilResolve<Format>(*reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassDescriptionDepthStencilResolve*" : "VkSubpassDescriptionDepthStencilResolve"), "pNext", indents, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
            dump_VkPhysicalDeviceDepthStencilResolveProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthStencilResolveProperties*" : "VkPhysicalDeviceDepthStencilResolveProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
            dump_VkImageStencilUsageCreateInfo<Format>(*reinterpret_cast<const VkImageStencilUsageCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageStencilUsageCreateInfo*" : "VkImageStencilUsageCreateInfo"), "pNext", indents, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
            dump_VkPhysicalDeviceImagelessFramebufferFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImagelessFramebufferFeatures*" : "VkPhysicalDeviceImagelessFramebufferFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
            dump_VkFramebufferAttachmentImageInfo<Format>(*reinterpret_cast<const VkFramebufferAttachmentImageInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFramebufferAttachmentImageInfo*" : "VkFramebufferAttachmentImageInfo"), "pNext", indents, reinterpret_cast<const VkFramebufferAttachmentImageInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
            dump_VkRenderPassAttachmentBeginInfo<Format>(*reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassAttachmentBeginInfo*" : "VkRenderPassAttachmentBeginInfo"), "pNext", indents, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
            dump_VkFramebufferAttachmentsCreateInfo<Format>(*reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFramebufferAttachmentsCreateInfo*" : "VkFramebufferAttachmentsCreateInfo"), "pNext", indents, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
            dump_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*" : "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
            dump_VkAttachmentReferenceStencilLayout<Format>(*reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentReferenceStencilLayout*" : "VkAttachmentReferenceStencilLayout"), "pNext", indents, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(object));
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
            dump_VkAttachmentDescriptionStencilLayout<Format>(*reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentDescriptionStencilLayout*" : "VkAttachmentDescriptionStencilLayout"), "pNext", indents, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
            dump_VkPhysicalDeviceVulkan13Features<Format>(*reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan13Features*" : "VkPhysicalDeviceVulkan13Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
            dump_VkPhysicalDeviceVulkan13Properties<Format>(*reinterpret_cast<const VkPhysicalDeviceVulkan13Properties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan13Properties*" : "VkPhysicalDeviceVulkan13Properties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVulkan13Properties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES:
            dump_VkPhysicalDeviceToolProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceToolProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceToolProperties*" : "VkPhysicalDeviceToolProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceToolProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
            dump_VkPhysicalDevicePrivateDataFeatures<Format>(*reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePrivateDataFeatures*" : "VkPhysicalDevicePrivateDataFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
            dump_VkDevicePrivateDataCreateInfo<Format>(*reinterpret_cast<const VkDevicePrivateDataCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDevicePrivateDataCreateInfo*" : "VkDevicePrivateDataCreateInfo"), "pNext", indents, reinterpret_cast<const VkDevicePrivateDataCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO:
            dump_VkPrivateDataSlotCreateInfo<Format>(*reinterpret_cast<const VkPrivateDataSlotCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPrivateDataSlotCreateInfo*" : "VkPrivateDataSlotCreateInfo"), "pNext", indents, reinterpret_cast<const VkPrivateDataSlotCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
            dump_VkMemoryBarrier2<Format>(*reinterpret_cast<const VkMemoryBarrier2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryBarrier2*" : "VkMemoryBarrier2"), "pNext", indents, reinterpret_cast<const VkMemoryBarrier2*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2:
            dump_VkBufferMemoryBarrier2<Format>(*reinterpret_cast<const VkBufferMemoryBarrier2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferMemoryBarrier2*" : "VkBufferMemoryBarrier2"), "pNext", indents, reinterpret_cast<const VkBufferMemoryBarrier2*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2:
            dump_VkImageMemoryBarrier2<Format>(*reinterpret_cast<const VkImageMemoryBarrier2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageMemoryBarrier2*" : "VkImageMemoryBarrier2"), "pNext", indents, reinterpret_cast<const VkImageMemoryBarrier2*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEPENDENCY_INFO:
            dump_VkDependencyInfo<Format>(*reinterpret_cast<const VkDependencyInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDependencyInfo*" : "VkDependencyInfo"), "pNext", indents, reinterpret_cast<const VkDependencyInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO:
            dump_VkSemaphoreSubmitInfo<Format>(*reinterpret_cast<const VkSemaphoreSubmitInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreSubmitInfo*" : "VkSemaphoreSubmitInfo"), "pNext", indents, reinterpret_cast<const VkSemaphoreSubmitInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO:
            dump_VkCommandBufferSubmitInfo<Format>(*reinterpret_cast<const VkCommandBufferSubmitInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferSubmitInfo*" : "VkCommandBufferSubmitInfo"), "pNext", indents, reinterpret_cast<const VkCommandBufferSubmitInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SUBMIT_INFO_2:
            dump_VkSubmitInfo2<Format>(*reinterpret_cast<const VkSubmitInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubmitInfo2*" : "VkSubmitInfo2"), "pNext", indents, reinterpret_cast<const VkSubmitInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
            dump_VkPhysicalDeviceSynchronization2Features<Format>(*reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSynchronization2Features*" : "VkPhysicalDeviceSynchronization2Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COPY_2:
            dump_VkBufferCopy2<Format>(*reinterpret_cast<const VkBufferCopy2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCopy2*" : "VkBufferCopy2"), "pNext", indents, reinterpret_cast<const VkBufferCopy2*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2:
            dump_VkCopyBufferInfo2<Format>(*reinterpret_cast<const VkCopyBufferInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyBufferInfo2*" : "VkCopyBufferInfo2"), "pNext", indents, reinterpret_cast<const VkCopyBufferInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_COPY_2:
            dump_VkImageCopy2<Format>(*reinterpret_cast<const VkImageCopy2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageCopy2*" : "VkImageCopy2"), "pNext", indents, reinterpret_cast<const VkImageCopy2*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2:
            dump_VkCopyImageInfo2<Format>(*reinterpret_cast<const VkCopyImageInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyImageInfo2*" : "VkCopyImageInfo2"), "pNext", indents, reinterpret_cast<const VkCopyImageInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2:
            dump_VkBufferImageCopy2<Format>(*reinterpret_cast<const VkBufferImageCopy2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferImageCopy2*" : "VkBufferImageCopy2"), "pNext", indents, reinterpret_cast<const VkBufferImageCopy2*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2:
            dump_VkCopyBufferToImageInfo2<Format>(*reinterpret_cast<const VkCopyBufferToImageInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyBufferToImageInfo2*" : "VkCopyBufferToImageInfo2"), "pNext", indents, reinterpret_cast<const VkCopyBufferToImageInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2:
            dump_VkCopyImageToBufferInfo2<Format>(*reinterpret_cast<const VkCopyImageToBufferInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyImageToBufferInfo2*" : "VkCopyImageToBufferInfo2"), "pNext", indents, reinterpret_cast<const VkCopyImageToBufferInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
            dump_VkPhysicalDeviceTextureCompressionASTCHDRFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTextureCompressionASTCHDRFeatures*" : "VkPhysicalDeviceTextureCompressionASTCHDRFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
            dump_VkFormatProperties3<Format>(*reinterpret_cast<const VkFormatProperties3*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFormatProperties3*" : "VkFormatProperties3"), "pNext", indents, reinterpret_cast<const VkFormatProperties3*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
            dump_VkPhysicalDeviceMaintenance4Features<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance4Features*" : "VkPhysicalDeviceMaintenance4Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
            dump_VkPhysicalDeviceMaintenance4Properties<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance4Properties*" : "VkPhysicalDeviceMaintenance4Properties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS:
            dump_VkDeviceBufferMemoryRequirements<Format>(*reinterpret_cast<const VkDeviceBufferMemoryRequirements*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceBufferMemoryRequirements*" : "VkDeviceBufferMemoryRequirements"), "pNext", indents, reinterpret_cast<const VkDeviceBufferMemoryRequirements*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS:
            dump_VkDeviceImageMemoryRequirements<Format>(*reinterpret_cast<const VkDeviceImageMemoryRequirements*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceImageMemoryRequirements*" : "VkDeviceImageMemoryRequirements"), "pNext", indents, reinterpret_cast<const VkDeviceImageMemoryRequirements*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
            dump_VkPipelineCreationFeedbackCreateInfo<Format>(*reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCreationFeedbackCreateInfo*" : "VkPipelineCreationFeedbackCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
            dump_VkPhysicalDeviceShaderTerminateInvocationFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderTerminateInvocationFeatures*" : "VkPhysicalDeviceShaderTerminateInvocationFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
            dump_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*" : "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
            dump_VkPhysicalDevicePipelineCreationCacheControlFeatures<Format>(*reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineCreationCacheControlFeatures*" : "VkPhysicalDevicePipelineCreationCacheControlFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
            dump_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*" : "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
            dump_VkPhysicalDeviceImageRobustnessFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageRobustnessFeatures*" : "VkPhysicalDeviceImageRobustnessFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
            dump_VkPhysicalDeviceSubgroupSizeControlFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubgroupSizeControlFeatures*" : "VkPhysicalDeviceSubgroupSizeControlFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
            dump_VkPhysicalDeviceSubgroupSizeControlProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubgroupSizeControlProperties*" : "VkPhysicalDeviceSubgroupSizeControlProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
            dump_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo<Format>(*reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*" : "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
            dump_VkPhysicalDeviceInlineUniformBlockFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceInlineUniformBlockFeatures*" : "VkPhysicalDeviceInlineUniformBlockFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
            dump_VkPhysicalDeviceInlineUniformBlockProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceInlineUniformBlockProperties*" : "VkPhysicalDeviceInlineUniformBlockProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
            dump_VkWriteDescriptorSetInlineUniformBlock<Format>(*reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSetInlineUniformBlock*" : "VkWriteDescriptorSetInlineUniformBlock"), "pNext", indents, reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
            dump_VkDescriptorPoolInlineUniformBlockCreateInfo<Format>(*reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorPoolInlineUniformBlockCreateInfo*" : "VkDescriptorPoolInlineUniformBlockCreateInfo"), "pNext", indents, reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
            dump_VkPhysicalDeviceShaderIntegerDotProductFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderIntegerDotProductFeatures*" : "VkPhysicalDeviceShaderIntegerDotProductFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
            dump_VkPhysicalDeviceShaderIntegerDotProductProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderIntegerDotProductProperties*" : "VkPhysicalDeviceShaderIntegerDotProductProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
            dump_VkPhysicalDeviceTexelBufferAlignmentProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTexelBufferAlignmentProperties*" : "VkPhysicalDeviceTexelBufferAlignmentProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_BLIT_2:
            dump_VkImageBlit2<Format>(*reinterpret_cast<const VkImageBlit2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageBlit2*" : "VkImageBlit2"), "pNext", indents, reinterpret_cast<const VkImageBlit2*>(object));
            break;

        case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2:
            dump_VkBlitImageInfo2<Format>(*reinterpret_cast<const VkBlitImageInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBlitImageInfo2*" : "VkBlitImageInfo2"), "pNext", indents, reinterpret_cast<const VkBlitImageInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2:
            dump_VkImageResolve2<Format>(*reinterpret_cast<const VkImageResolve2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageResolve2*" : "VkImageResolve2"), "pNext", indents, reinterpret_cast<const VkImageResolve2*>(object));
            break;

        case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2:
            dump_VkResolveImageInfo2<Format>(*reinterpret_cast<const VkResolveImageInfo2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkResolveImageInfo2*" : "VkResolveImageInfo2"), "pNext", indents, reinterpret_cast<const VkResolveImageInfo2*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO:
            dump_VkRenderingAttachmentInfo<Format>(*reinterpret_cast<const VkRenderingAttachmentInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingAttachmentInfo*" : "VkRenderingAttachmentInfo"), "pNext", indents, reinterpret_cast<const VkRenderingAttachmentInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDERING_INFO:
            dump_VkRenderingInfo<Format>(*reinterpret_cast<const VkRenderingInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingInfo*" : "VkRenderingInfo"), "pNext", indents, reinterpret_cast<const VkRenderingInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
            dump_VkPipelineRenderingCreateInfo<Format>(*reinterpret_cast<const VkPipelineRenderingCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRenderingCreateInfo*" : "VkPipelineRenderingCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineRenderingCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
            dump_VkPhysicalDeviceDynamicRenderingFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDynamicRenderingFeatures*" : "VkPhysicalDeviceDynamicRenderingFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
            dump_VkCommandBufferInheritanceRenderingInfo<Format>(*reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceRenderingInfo*" : "VkCommandBufferInheritanceRenderingInfo"), "pNext", indents, reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
            dump_VkPhysicalDeviceVulkan14Features<Format>(*reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan14Features*" : "VkPhysicalDeviceVulkan14Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
            dump_VkPhysicalDeviceVulkan14Properties<Format>(*reinterpret_cast<const VkPhysicalDeviceVulkan14Properties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan14Properties*" : "VkPhysicalDeviceVulkan14Properties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVulkan14Properties*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO:
            dump_VkDeviceQueueGlobalPriorityCreateInfo<Format>(*reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceQueueGlobalPriorityCreateInfo*" : "VkDeviceQueueGlobalPriorityCreateInfo"), "pNext", indents, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
            dump_VkPhysicalDeviceGlobalPriorityQueryFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceGlobalPriorityQueryFeatures*" : "VkPhysicalDeviceGlobalPriorityQueryFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES:
            dump_VkQueueFamilyGlobalPriorityProperties<Format>(*reinterpret_cast<const VkQueueFamilyGlobalPriorityProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyGlobalPriorityProperties*" : "VkQueueFamilyGlobalPriorityProperties"), "pNext", indents, reinterpret_cast<const VkQueueFamilyGlobalPriorityProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
            dump_VkPhysicalDeviceIndexTypeUint8Features<Format>(*reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceIndexTypeUint8Features*" : "VkPhysicalDeviceIndexTypeUint8Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO:
            dump_VkMemoryMapInfo<Format>(*reinterpret_cast<const VkMemoryMapInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryMapInfo*" : "VkMemoryMapInfo"), "pNext", indents, reinterpret_cast<const VkMemoryMapInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO:
            dump_VkMemoryUnmapInfo<Format>(*reinterpret_cast<const VkMemoryUnmapInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryUnmapInfo*" : "VkMemoryUnmapInfo"), "pNext", indents, reinterpret_cast<const VkMemoryUnmapInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
            dump_VkPhysicalDeviceMaintenance5Features<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance5Features*" : "VkPhysicalDeviceMaintenance5Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
            dump_VkPhysicalDeviceMaintenance5Properties<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance5Properties*" : "VkPhysicalDeviceMaintenance5Properties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties*>(object));
            break;

        case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2:
            dump_VkSubresourceLayout2<Format>(*reinterpret_cast<const VkSubresourceLayout2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubresourceLayout2*" : "VkSubresourceLayout2"), "pNext", indents, reinterpret_cast<const VkSubresourceLayout2*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2:
            dump_VkImageSubresource2<Format>(*reinterpret_cast<const VkImageSubresource2*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageSubresource2*" : "VkImageSubresource2"), "pNext", indents, reinterpret_cast<const VkImageSubresource2*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO:
            dump_VkDeviceImageSubresourceInfo<Format>(*reinterpret_cast<const VkDeviceImageSubresourceInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceImageSubresourceInfo*" : "VkDeviceImageSubresourceInfo"), "pNext", indents, reinterpret_cast<const VkDeviceImageSubresourceInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO:
            dump_VkBufferUsageFlags2CreateInfo<Format>(*reinterpret_cast<const VkBufferUsageFlags2CreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferUsageFlags2CreateInfo*" : "VkBufferUsageFlags2CreateInfo"), "pNext", indents, reinterpret_cast<const VkBufferUsageFlags2CreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
            dump_VkPhysicalDeviceMaintenance6Features<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance6Features*" : "VkPhysicalDeviceMaintenance6Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
            dump_VkPhysicalDeviceMaintenance6Properties<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance6Properties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance6Properties*" : "VkPhysicalDeviceMaintenance6Properties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance6Properties*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS:
            dump_VkBindMemoryStatus<Format>(*reinterpret_cast<const VkBindMemoryStatus*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindMemoryStatus*" : "VkBindMemoryStatus"), "pNext", indents, reinterpret_cast<const VkBindMemoryStatus*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
            dump_VkPhysicalDeviceHostImageCopyFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceHostImageCopyFeatures*" : "VkPhysicalDeviceHostImageCopyFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
            dump_VkPhysicalDeviceHostImageCopyProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceHostImageCopyProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceHostImageCopyProperties*" : "VkPhysicalDeviceHostImageCopyProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceHostImageCopyProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY:
            dump_VkMemoryToImageCopy<Format>(*reinterpret_cast<const VkMemoryToImageCopy*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryToImageCopy*" : "VkMemoryToImageCopy"), "pNext", indents, reinterpret_cast<const VkMemoryToImageCopy*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY:
            dump_VkImageToMemoryCopy<Format>(*reinterpret_cast<const VkImageToMemoryCopy*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageToMemoryCopy*" : "VkImageToMemoryCopy"), "pNext", indents, reinterpret_cast<const VkImageToMemoryCopy*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO:
            dump_VkCopyMemoryToImageInfo<Format>(*reinterpret_cast<const VkCopyMemoryToImageInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMemoryToImageInfo*" : "VkCopyMemoryToImageInfo"), "pNext", indents, reinterpret_cast<const VkCopyMemoryToImageInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO:
            dump_VkCopyImageToMemoryInfo<Format>(*reinterpret_cast<const VkCopyImageToMemoryInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyImageToMemoryInfo*" : "VkCopyImageToMemoryInfo"), "pNext", indents, reinterpret_cast<const VkCopyImageToMemoryInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO:
            dump_VkCopyImageToImageInfo<Format>(*reinterpret_cast<const VkCopyImageToImageInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyImageToImageInfo*" : "VkCopyImageToImageInfo"), "pNext", indents, reinterpret_cast<const VkCopyImageToImageInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO:
            dump_VkHostImageLayoutTransitionInfo<Format>(*reinterpret_cast<const VkHostImageLayoutTransitionInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkHostImageLayoutTransitionInfo*" : "VkHostImageLayoutTransitionInfo"), "pNext", indents, reinterpret_cast<const VkHostImageLayoutTransitionInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
            dump_VkSubresourceHostMemcpySize<Format>(*reinterpret_cast<const VkSubresourceHostMemcpySize*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubresourceHostMemcpySize*" : "VkSubresourceHostMemcpySize"), "pNext", indents, reinterpret_cast<const VkSubresourceHostMemcpySize*>(object));
            break;

        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY:
            dump_VkHostImageCopyDevicePerformanceQuery<Format>(*reinterpret_cast<const VkHostImageCopyDevicePerformanceQuery*>(object), settings, (Format == ApiDumpFormat::Json ? "VkHostImageCopyDevicePerformanceQuery*" : "VkHostImageCopyDevicePerformanceQuery"), "pNext", indents, reinterpret_cast<const VkHostImageCopyDevicePerformanceQuery*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
            dump_VkPhysicalDeviceShaderSubgroupRotateFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSubgroupRotateFeatures*" : "VkPhysicalDeviceShaderSubgroupRotateFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
            dump_VkPhysicalDeviceShaderFloatControls2Features<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderFloatControls2Features*" : "VkPhysicalDeviceShaderFloatControls2Features"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
            dump_VkPhysicalDeviceShaderExpectAssumeFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderExpectAssumeFeatures*" : "VkPhysicalDeviceShaderExpectAssumeFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
            dump_VkPipelineCreateFlags2CreateInfo<Format>(*reinterpret_cast<const VkPipelineCreateFlags2CreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCreateFlags2CreateInfo*" : "VkPipelineCreateFlags2CreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineCreateFlags2CreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
            dump_VkPhysicalDevicePushDescriptorProperties<Format>(*reinterpret_cast<const VkPhysicalDevicePushDescriptorProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePushDescriptorProperties*" : "VkPhysicalDevicePushDescriptorProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePushDescriptorProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO:
            dump_VkBindDescriptorSetsInfo<Format>(*reinterpret_cast<const VkBindDescriptorSetsInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindDescriptorSetsInfo*" : "VkBindDescriptorSetsInfo"), "pNext", indents, reinterpret_cast<const VkBindDescriptorSetsInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO:
            dump_VkPushConstantsInfo<Format>(*reinterpret_cast<const VkPushConstantsInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPushConstantsInfo*" : "VkPushConstantsInfo"), "pNext", indents, reinterpret_cast<const VkPushConstantsInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO:
            dump_VkPushDescriptorSetInfo<Format>(*reinterpret_cast<const VkPushDescriptorSetInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPushDescriptorSetInfo*" : "VkPushDescriptorSetInfo"), "pNext", indents, reinterpret_cast<const VkPushDescriptorSetInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO:
            dump_VkPushDescriptorSetWithTemplateInfo<Format>(*reinterpret_cast<const VkPushDescriptorSetWithTemplateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPushDescriptorSetWithTemplateInfo*" : "VkPushDescriptorSetWithTemplateInfo"), "pNext", indents, reinterpret_cast<const VkPushDescriptorSetWithTemplateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
            dump_VkPhysicalDevicePipelineProtectedAccessFeatures<Format>(*reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineProtectedAccessFeatures*" : "VkPhysicalDevicePipelineProtectedAccessFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
            dump_VkPhysicalDevicePipelineRobustnessFeatures<Format>(*reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineRobustnessFeatures*" : "VkPhysicalDevicePipelineRobustnessFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
            dump_VkPhysicalDevicePipelineRobustnessProperties<Format>(*reinterpret_cast<const VkPhysicalDevicePipelineRobustnessProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineRobustnessProperties*" : "VkPhysicalDevicePipelineRobustnessProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePipelineRobustnessProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
            dump_VkPipelineRobustnessCreateInfo<Format>(*reinterpret_cast<const VkPipelineRobustnessCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRobustnessCreateInfo*" : "VkPipelineRobustnessCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineRobustnessCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
            dump_VkPhysicalDeviceLineRasterizationFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLineRasterizationFeatures*" : "VkPhysicalDeviceLineRasterizationFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
            dump_VkPhysicalDeviceLineRasterizationProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceLineRasterizationProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLineRasterizationProperties*" : "VkPhysicalDeviceLineRasterizationProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceLineRasterizationProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO:
            dump_VkPipelineRasterizationLineStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationLineStateCreateInfo*" : "VkPipelineRasterizationLineStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
            dump_VkPhysicalDeviceVertexAttributeDivisorProperties<Format>(*reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorProperties*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVertexAttributeDivisorProperties*" : "VkPhysicalDeviceVertexAttributeDivisorProperties"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorProperties*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO:
            dump_VkPipelineVertexInputDivisorStateCreateInfo<Format>(*reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineVertexInputDivisorStateCreateInfo*" : "VkPipelineVertexInputDivisorStateCreateInfo"), "pNext", indents, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
            dump_VkPhysicalDeviceVertexAttributeDivisorFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVertexAttributeDivisorFeatures*" : "VkPhysicalDeviceVertexAttributeDivisorFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO:
            dump_VkRenderingAreaInfo<Format>(*reinterpret_cast<const VkRenderingAreaInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingAreaInfo*" : "VkRenderingAreaInfo"), "pNext", indents, reinterpret_cast<const VkRenderingAreaInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
            dump_VkPhysicalDeviceDynamicRenderingLocalReadFeatures<Format>(*reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDynamicRenderingLocalReadFeatures*" : "VkPhysicalDeviceDynamicRenderingLocalReadFeatures"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO:
            dump_VkRenderingAttachmentLocationInfo<Format>(*reinterpret_cast<const VkRenderingAttachmentLocationInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingAttachmentLocationInfo*" : "VkRenderingAttachmentLocationInfo"), "pNext", indents, reinterpret_cast<const VkRenderingAttachmentLocationInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO:
            dump_VkRenderingInputAttachmentIndexInfo<Format>(*reinterpret_cast<const VkRenderingInputAttachmentIndexInfo*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingInputAttachmentIndexInfo*" : "VkRenderingInputAttachmentIndexInfo"), "pNext", indents, reinterpret_cast<const VkRenderingInputAttachmentIndexInfo*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:
            dump_VkSwapchainCreateInfoKHR<Format>(*reinterpret_cast<const VkSwapchainCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainCreateInfoKHR*" : "VkSwapchainCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkSwapchainCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
            dump_VkPresentInfoKHR<Format>(*reinterpret_cast<const VkPresentInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentInfoKHR*" : "VkPresentInfoKHR"), "pNext", indents, reinterpret_cast<const VkPresentInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
            dump_VkImageSwapchainCreateInfoKHR<Format>(*reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageSwapchainCreateInfoKHR*" : "VkImageSwapchainCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
            dump_VkBindImageMemorySwapchainInfoKHR<Format>(*reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindImageMemorySwapchainInfoKHR*" : "VkBindImageMemorySwapchainInfoKHR"), "pNext", indents, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR:
            dump_VkAcquireNextImageInfoKHR<Format>(*reinterpret_cast<const VkAcquireNextImageInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAcquireNextImageInfoKHR*" : "VkAcquireNextImageInfoKHR"), "pNext", indents, reinterpret_cast<const VkAcquireNextImageInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR:
            dump_VkDeviceGroupPresentCapabilitiesKHR<Format>(*reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupPresentCapabilitiesKHR*" : "VkDeviceGroupPresentCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
            dump_VkDeviceGroupPresentInfoKHR<Format>(*reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupPresentInfoKHR*" : "VkDeviceGroupPresentInfoKHR"), "pNext", indents, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
            dump_VkDeviceGroupSwapchainCreateInfoKHR<Format>(*reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupSwapchainCreateInfoKHR*" : "VkDeviceGroupSwapchainCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:
            dump_VkDisplayModeCreateInfoKHR<Format>(*reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayModeCreateInfoKHR*" : "VkDisplayModeCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:
            dump_VkDisplaySurfaceCreateInfoKHR<Format>(*reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplaySurfaceCreateInfoKHR*" : "VkDisplaySurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
            dump_VkDisplayPresentInfoKHR<Format>(*reinterpret_cast<const VkDisplayPresentInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayPresentInfoKHR*" : "VkDisplayPresentInfoKHR"), "pNext", indents, reinterpret_cast<const VkDisplayPresentInfoKHR*>(object));
            break;
#if defined(VK_USE_PLATFORM_XLIB_KHR)

        case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:
            dump_VkXlibSurfaceCreateInfoKHR<Format>(*reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkXlibSurfaceCreateInfoKHR*" : "VkXlibSurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(object));
            break;
#endif  // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)

        case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR:
            dump_VkXcbSurfaceCreateInfoKHR<Format>(*reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkXcbSurfaceCreateInfoKHR*" : "VkXcbSurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(object));
            break;
#endif  // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)

        case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR:
            dump_VkWaylandSurfaceCreateInfoKHR<Format>(*reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWaylandSurfaceCreateInfoKHR*" : "VkWaylandSurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(object));
            break;
#endif  // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)

        case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR:
            dump_VkAndroidSurfaceCreateInfoKHR<Format>(*reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidSurfaceCreateInfoKHR*" : "VkAndroidSurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(object));
            break;
#endif  // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR:
            dump_VkWin32SurfaceCreateInfoKHR<Format>(*reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWin32SurfaceCreateInfoKHR*" : "VkWin32SurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(object));
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
            dump_VkQueueFamilyQueryResultStatusPropertiesKHR<Format>(*reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyQueryResultStatusPropertiesKHR*" : "VkQueueFamilyQueryResultStatusPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
            dump_VkQueueFamilyVideoPropertiesKHR<Format>(*reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyVideoPropertiesKHR*" : "VkQueueFamilyVideoPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
            dump_VkVideoProfileInfoKHR<Format>(*reinterpret_cast<const VkVideoProfileInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoProfileInfoKHR*" : "VkVideoProfileInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoProfileInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
            dump_VkVideoProfileListInfoKHR<Format>(*reinterpret_cast<const VkVideoProfileListInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoProfileListInfoKHR*" : "VkVideoProfileListInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoProfileListInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR:
            dump_VkVideoCapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoCapabilitiesKHR*" : "VkVideoCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoCapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR:
            dump_VkPhysicalDeviceVideoFormatInfoKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoFormatInfoKHR*" : "VkPhysicalDeviceVideoFormatInfoKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR:
            dump_VkVideoFormatPropertiesKHR<Format>(*reinterpret_cast<const VkVideoFormatPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoFormatPropertiesKHR*" : "VkVideoFormatPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoFormatPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR:
            dump_VkVideoPictureResourceInfoKHR<Format>(*reinterpret_cast<const VkVideoPictureResourceInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoPictureResourceInfoKHR*" : "VkVideoPictureResourceInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoPictureResourceInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR:
            dump_VkVideoReferenceSlotInfoKHR<Format>(*reinterpret_cast<const VkVideoReferenceSlotInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoReferenceSlotInfoKHR*" : "VkVideoReferenceSlotInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoReferenceSlotInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR:
            dump_VkVideoSessionMemoryRequirementsKHR<Format>(*reinterpret_cast<const VkVideoSessionMemoryRequirementsKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoSessionMemoryRequirementsKHR*" : "VkVideoSessionMemoryRequirementsKHR"), "pNext", indents, reinterpret_cast<const VkVideoSessionMemoryRequirementsKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR:
            dump_VkBindVideoSessionMemoryInfoKHR<Format>(*reinterpret_cast<const VkBindVideoSessionMemoryInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindVideoSessionMemoryInfoKHR*" : "VkBindVideoSessionMemoryInfoKHR"), "pNext", indents, reinterpret_cast<const VkBindVideoSessionMemoryInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR:
            dump_VkVideoSessionCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoSessionCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoSessionCreateInfoKHR*" : "VkVideoSessionCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoSessionCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_VkVideoSessionParametersCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoSessionParametersCreateInfoKHR*" : "VkVideoSessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR:
            dump_VkVideoSessionParametersUpdateInfoKHR<Format>(*reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoSessionParametersUpdateInfoKHR*" : "VkVideoSessionParametersUpdateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR:
            dump_VkVideoBeginCodingInfoKHR<Format>(*reinterpret_cast<const VkVideoBeginCodingInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoBeginCodingInfoKHR*" : "VkVideoBeginCodingInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoBeginCodingInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR:
            dump_VkVideoEndCodingInfoKHR<Format>(*reinterpret_cast<const VkVideoEndCodingInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEndCodingInfoKHR*" : "VkVideoEndCodingInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEndCodingInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR:
            dump_VkVideoCodingControlInfoKHR<Format>(*reinterpret_cast<const VkVideoCodingControlInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoCodingControlInfoKHR*" : "VkVideoCodingControlInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoCodingControlInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
            dump_VkVideoDecodeCapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoDecodeCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeCapabilitiesKHR*" : "VkVideoDecodeCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeCapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
            dump_VkVideoDecodeUsageInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeUsageInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeUsageInfoKHR*" : "VkVideoDecodeUsageInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeUsageInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR:
            dump_VkVideoDecodeInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeInfoKHR*" : "VkVideoDecodeInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR:
            dump_VkVideoEncodeH264CapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264CapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264CapabilitiesKHR*" : "VkVideoEncodeH264CapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264CapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_VkVideoEncodeH264QualityLevelPropertiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264QualityLevelPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264QualityLevelPropertiesKHR*" : "VkVideoEncodeH264QualityLevelPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264QualityLevelPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
            dump_VkVideoEncodeH264SessionCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264SessionCreateInfoKHR*" : "VkVideoEncodeH264SessionCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_VkVideoEncodeH264SessionParametersAddInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264SessionParametersAddInfoKHR*" : "VkVideoEncodeH264SessionParametersAddInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_VkVideoEncodeH264SessionParametersCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264SessionParametersCreateInfoKHR*" : "VkVideoEncodeH264SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR:
            dump_VkVideoEncodeH264SessionParametersGetInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264SessionParametersGetInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264SessionParametersGetInfoKHR*" : "VkVideoEncodeH264SessionParametersGetInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264SessionParametersGetInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
            dump_VkVideoEncodeH264SessionParametersFeedbackInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264SessionParametersFeedbackInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264SessionParametersFeedbackInfoKHR*" : "VkVideoEncodeH264SessionParametersFeedbackInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264SessionParametersFeedbackInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR:
            dump_VkVideoEncodeH264NaluSliceInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264NaluSliceInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264NaluSliceInfoKHR*" : "VkVideoEncodeH264NaluSliceInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264NaluSliceInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR:
            dump_VkVideoEncodeH264PictureInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264PictureInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264PictureInfoKHR*" : "VkVideoEncodeH264PictureInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264PictureInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
            dump_VkVideoEncodeH264DpbSlotInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264DpbSlotInfoKHR*" : "VkVideoEncodeH264DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
            dump_VkVideoEncodeH264ProfileInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264ProfileInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264ProfileInfoKHR*" : "VkVideoEncodeH264ProfileInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264ProfileInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
            dump_VkVideoEncodeH264RateControlInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264RateControlInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264RateControlInfoKHR*" : "VkVideoEncodeH264RateControlInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264RateControlInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
            dump_VkVideoEncodeH264RateControlLayerInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264RateControlLayerInfoKHR*" : "VkVideoEncodeH264RateControlLayerInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR:
            dump_VkVideoEncodeH264GopRemainingFrameInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264GopRemainingFrameInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264GopRemainingFrameInfoKHR*" : "VkVideoEncodeH264GopRemainingFrameInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264GopRemainingFrameInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR:
            dump_VkVideoEncodeH265CapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265CapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265CapabilitiesKHR*" : "VkVideoEncodeH265CapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265CapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR:
            dump_VkVideoEncodeH265SessionCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265SessionCreateInfoKHR*" : "VkVideoEncodeH265SessionCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_VkVideoEncodeH265QualityLevelPropertiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265QualityLevelPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265QualityLevelPropertiesKHR*" : "VkVideoEncodeH265QualityLevelPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265QualityLevelPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_VkVideoEncodeH265SessionParametersAddInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265SessionParametersAddInfoKHR*" : "VkVideoEncodeH265SessionParametersAddInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_VkVideoEncodeH265SessionParametersCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265SessionParametersCreateInfoKHR*" : "VkVideoEncodeH265SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR:
            dump_VkVideoEncodeH265SessionParametersGetInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265SessionParametersGetInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265SessionParametersGetInfoKHR*" : "VkVideoEncodeH265SessionParametersGetInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265SessionParametersGetInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
            dump_VkVideoEncodeH265SessionParametersFeedbackInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265SessionParametersFeedbackInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265SessionParametersFeedbackInfoKHR*" : "VkVideoEncodeH265SessionParametersFeedbackInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265SessionParametersFeedbackInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR:
            dump_VkVideoEncodeH265NaluSliceSegmentInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265NaluSliceSegmentInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265NaluSliceSegmentInfoKHR*" : "VkVideoEncodeH265NaluSliceSegmentInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265NaluSliceSegmentInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR:
            dump_VkVideoEncodeH265PictureInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265PictureInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265PictureInfoKHR*" : "VkVideoEncodeH265PictureInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265PictureInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR:
            dump_VkVideoEncodeH265DpbSlotInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265DpbSlotInfoKHR*" : "VkVideoEncodeH265DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR:
            dump_VkVideoEncodeH265ProfileInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265ProfileInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265ProfileInfoKHR*" : "VkVideoEncodeH265ProfileInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265ProfileInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR:
            dump_VkVideoEncodeH265RateControlInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265RateControlInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265RateControlInfoKHR*" : "VkVideoEncodeH265RateControlInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265RateControlInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR:
            dump_VkVideoEncodeH265RateControlLayerInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265RateControlLayerInfoKHR*" : "VkVideoEncodeH265RateControlLayerInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR:
            dump_VkVideoEncodeH265GopRemainingFrameInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265GopRemainingFrameInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265GopRemainingFrameInfoKHR*" : "VkVideoEncodeH265GopRemainingFrameInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265GopRemainingFrameInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR:
            dump_VkVideoDecodeH264ProfileInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264ProfileInfoKHR*" : "VkVideoDecodeH264ProfileInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR:
            dump_VkVideoDecodeH264CapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264CapabilitiesKHR*" : "VkVideoDecodeH264CapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_VkVideoDecodeH264SessionParametersAddInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264SessionParametersAddInfoKHR*" : "VkVideoDecodeH264SessionParametersAddInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_VkVideoDecodeH264SessionParametersCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264SessionParametersCreateInfoKHR*" : "VkVideoDecodeH264SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR:
            dump_VkVideoDecodeH264PictureInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264PictureInfoKHR*" : "VkVideoDecodeH264PictureInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
            dump_VkVideoDecodeH264DpbSlotInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264DpbSlotInfoKHR*" : "VkVideoDecodeH264DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR*>(object));
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
            dump_VkImportMemoryWin32HandleInfoKHR<Format>(*reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryWin32HandleInfoKHR*" : "VkImportMemoryWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
            dump_VkExportMemoryWin32HandleInfoKHR<Format>(*reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMemoryWin32HandleInfoKHR*" : "VkExportMemoryWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
            dump_VkMemoryWin32HandlePropertiesKHR<Format>(*reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryWin32HandlePropertiesKHR*" : "VkMemoryWin32HandlePropertiesKHR"), "pNext", indents, reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
            dump_VkMemoryGetWin32HandleInfoKHR<Format>(*reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetWin32HandleInfoKHR*" : "VkMemoryGetWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>(object));
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
            dump_VkImportMemoryFdInfoKHR<Format>(*reinterpret_cast<const VkImportMemoryFdInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryFdInfoKHR*" : "VkImportMemoryFdInfoKHR"), "pNext", indents, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR:
            dump_VkMemoryFdPropertiesKHR<Format>(*reinterpret_cast<const VkMemoryFdPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryFdPropertiesKHR*" : "VkMemoryFdPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkMemoryFdPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR:
            dump_VkMemoryGetFdInfoKHR<Format>(*reinterpret_cast<const VkMemoryGetFdInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetFdInfoKHR*" : "VkMemoryGetFdInfoKHR"), "pNext", indents, reinterpret_cast<const VkMemoryGetFdInfoKHR*>(object));
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
            dump_VkWin32KeyedMutexAcquireReleaseInfoKHR<Format>(*reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWin32KeyedMutexAcquireReleaseInfoKHR*" : "VkWin32KeyedMutexAcquireReleaseInfoKHR"), "pNext", indents, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
            dump_VkImportSemaphoreWin32HandleInfoKHR<Format>(*reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportSemaphoreWin32HandleInfoKHR*" : "VkImportSemaphoreWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
            dump_VkExportSemaphoreWin32HandleInfoKHR<Format>(*reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportSemaphoreWin32HandleInfoKHR*" : "VkExportSemaphoreWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
            dump_VkD3D12FenceSubmitInfoKHR<Format>(*reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkD3D12FenceSubmitInfoKHR*" : "VkD3D12FenceSubmitInfoKHR"), "pNext", indents, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
            dump_VkSemaphoreGetWin32HandleInfoKHR<Format>(*reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreGetWin32HandleInfoKHR*" : "VkSemaphoreGetWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>(object));
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR:
            dump_VkImportSemaphoreFdInfoKHR<Format>(*reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportSemaphoreFdInfoKHR*" : "VkImportSemaphoreFdInfoKHR"), "pNext", indents, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:
            dump_VkSemaphoreGetFdInfoKHR<Format>(*reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreGetFdInfoKHR*" : "VkSemaphoreGetFdInfoKHR"), "pNext", indents, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
            dump_VkPresentRegionsKHR<Format>(*reinterpret_cast<const VkPresentRegionsKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentRegionsKHR*" : "VkPresentRegionsKHR"), "pNext", indents, reinterpret_cast<const VkPresentRegionsKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
            dump_VkSharedPresentSurfaceCapabilitiesKHR<Format>(*reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSharedPresentSurfaceCapabilitiesKHR*" : "VkSharedPresentSurfaceCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(object));
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
            dump_VkImportFenceWin32HandleInfoKHR<Format>(*reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportFenceWin32HandleInfoKHR*" : "VkImportFenceWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
            dump_VkExportFenceWin32HandleInfoKHR<Format>(*reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportFenceWin32HandleInfoKHR*" : "VkExportFenceWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
            dump_VkFenceGetWin32HandleInfoKHR<Format>(*reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFenceGetWin32HandleInfoKHR*" : "VkFenceGetWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>(object));
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR:
            dump_VkImportFenceFdInfoKHR<Format>(*reinterpret_cast<const VkImportFenceFdInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportFenceFdInfoKHR*" : "VkImportFenceFdInfoKHR"), "pNext", indents, reinterpret_cast<const VkImportFenceFdInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR:
            dump_VkFenceGetFdInfoKHR<Format>(*reinterpret_cast<const VkFenceGetFdInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFenceGetFdInfoKHR*" : "VkFenceGetFdInfoKHR"), "pNext", indents, reinterpret_cast<const VkFenceGetFdInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
            dump_VkPhysicalDevicePerformanceQueryFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePerformanceQueryFeaturesKHR*" : "VkPhysicalDevicePerformanceQueryFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
            dump_VkPhysicalDevicePerformanceQueryPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePerformanceQueryPropertiesKHR*" : "VkPhysicalDevicePerformanceQueryPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR:
            dump_VkPerformanceCounterKHR<Format>(*reinterpret_cast<const VkPerformanceCounterKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceCounterKHR*" : "VkPerformanceCounterKHR"), "pNext", indents, reinterpret_cast<const VkPerformanceCounterKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR:
            dump_VkPerformanceCounterDescriptionKHR<Format>(*reinterpret_cast<const VkPerformanceCounterDescriptionKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceCounterDescriptionKHR*" : "VkPerformanceCounterDescriptionKHR"), "pNext", indents, reinterpret_cast<const VkPerformanceCounterDescriptionKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
            dump_VkQueryPoolPerformanceCreateInfoKHR<Format>(*reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueryPoolPerformanceCreateInfoKHR*" : "VkQueryPoolPerformanceCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR:
            dump_VkAcquireProfilingLockInfoKHR<Format>(*reinterpret_cast<const VkAcquireProfilingLockInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAcquireProfilingLockInfoKHR*" : "VkAcquireProfilingLockInfoKHR"), "pNext", indents, reinterpret_cast<const VkAcquireProfilingLockInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
            dump_VkPerformanceQuerySubmitInfoKHR<Format>(*reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceQuerySubmitInfoKHR*" : "VkPerformanceQuerySubmitInfoKHR"), "pNext", indents, reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:
            dump_VkPhysicalDeviceSurfaceInfo2KHR<Format>(*reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSurfaceInfo2KHR*" : "VkPhysicalDeviceSurfaceInfo2KHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR:
            dump_VkSurfaceCapabilities2KHR<Format>(*reinterpret_cast<const VkSurfaceCapabilities2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilities2KHR*" : "VkSurfaceCapabilities2KHR"), "pNext", indents, reinterpret_cast<const VkSurfaceCapabilities2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR:
            dump_VkSurfaceFormat2KHR<Format>(*reinterpret_cast<const VkSurfaceFormat2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceFormat2KHR*" : "VkSurfaceFormat2KHR"), "pNext", indents, reinterpret_cast<const VkSurfaceFormat2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR:
            dump_VkDisplayProperties2KHR<Format>(*reinterpret_cast<const VkDisplayProperties2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayProperties2KHR*" : "VkDisplayProperties2KHR"), "pNext", indents, reinterpret_cast<const VkDisplayProperties2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR:
            dump_VkDisplayPlaneProperties2KHR<Format>(*reinterpret_cast<const VkDisplayPlaneProperties2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayPlaneProperties2KHR*" : "VkDisplayPlaneProperties2KHR"), "pNext", indents, reinterpret_cast<const VkDisplayPlaneProperties2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR:
            dump_VkDisplayModeProperties2KHR<Format>(*reinterpret_cast<const VkDisplayModeProperties2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayModeProperties2KHR*" : "VkDisplayModeProperties2KHR"), "pNext", indents, reinterpret_cast<const VkDisplayModeProperties2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR:
            dump_VkDisplayPlaneInfo2KHR<Format>(*reinterpret_cast<const VkDisplayPlaneInfo2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayPlaneInfo2KHR*" : "VkDisplayPlaneInfo2KHR"), "pNext", indents, reinterpret_cast<const VkDisplayPlaneInfo2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR:
            dump_VkDisplayPlaneCapabilities2KHR<Format>(*reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayPlaneCapabilities2KHR*" : "VkDisplayPlaneCapabilities2KHR"), "pNext", indents, reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
            dump_VkPhysicalDeviceShaderBfloat16FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderBfloat16FeaturesKHR*" : "VkPhysicalDeviceShaderBfloat16FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
            dump_VkPhysicalDevicePortabilitySubsetFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePortabilitySubsetFeaturesKHR*" : "VkPhysicalDevicePortabilitySubsetFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
            dump_VkPhysicalDevicePortabilitySubsetPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePortabilitySubsetPropertiesKHR*" : "VkPhysicalDevicePortabilitySubsetPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
            dump_VkPhysicalDeviceShaderClockFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderClockFeaturesKHR*" : "VkPhysicalDeviceShaderClockFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR:
            dump_VkVideoDecodeH265ProfileInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265ProfileInfoKHR*" : "VkVideoDecodeH265ProfileInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR:
            dump_VkVideoDecodeH265CapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265CapabilitiesKHR*" : "VkVideoDecodeH265CapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
            dump_VkVideoDecodeH265SessionParametersAddInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265SessionParametersAddInfoKHR*" : "VkVideoDecodeH265SessionParametersAddInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_VkVideoDecodeH265SessionParametersCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265SessionParametersCreateInfoKHR*" : "VkVideoDecodeH265SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR:
            dump_VkVideoDecodeH265PictureInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265PictureInfoKHR*" : "VkVideoDecodeH265PictureInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
            dump_VkVideoDecodeH265DpbSlotInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265DpbSlotInfoKHR*" : "VkVideoDecodeH265DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
            dump_VkFragmentShadingRateAttachmentInfoKHR<Format>(*reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFragmentShadingRateAttachmentInfoKHR*" : "VkFragmentShadingRateAttachmentInfoKHR"), "pNext", indents, reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
            dump_VkPipelineFragmentShadingRateStateCreateInfoKHR<Format>(*reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineFragmentShadingRateStateCreateInfoKHR*" : "VkPipelineFragmentShadingRateStateCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
            dump_VkPhysicalDeviceFragmentShadingRateFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShadingRateFeaturesKHR*" : "VkPhysicalDeviceFragmentShadingRateFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
            dump_VkPhysicalDeviceFragmentShadingRatePropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShadingRatePropertiesKHR*" : "VkPhysicalDeviceFragmentShadingRatePropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR:
            dump_VkPhysicalDeviceFragmentShadingRateKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShadingRateKHR*" : "VkPhysicalDeviceFragmentShadingRateKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
            dump_VkRenderingFragmentShadingRateAttachmentInfoKHR<Format>(*reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingFragmentShadingRateAttachmentInfoKHR*" : "VkRenderingFragmentShadingRateAttachmentInfoKHR"), "pNext", indents, reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR:
            dump_VkPhysicalDeviceShaderConstantDataFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderConstantDataFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderConstantDataFeaturesKHR*" : "VkPhysicalDeviceShaderConstantDataFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderConstantDataFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR:
            dump_VkPhysicalDeviceShaderAbortFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderAbortFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderAbortFeaturesKHR*" : "VkPhysicalDeviceShaderAbortFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderAbortFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR:
            dump_VkDeviceFaultShaderAbortMessageInfoKHR<Format>(*reinterpret_cast<const VkDeviceFaultShaderAbortMessageInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceFaultShaderAbortMessageInfoKHR*" : "VkDeviceFaultShaderAbortMessageInfoKHR"), "pNext", indents, reinterpret_cast<const VkDeviceFaultShaderAbortMessageInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR:
            dump_VkPhysicalDeviceShaderAbortPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderAbortPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderAbortPropertiesKHR*" : "VkPhysicalDeviceShaderAbortPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderAbortPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
            dump_VkPhysicalDeviceShaderQuadControlFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderQuadControlFeaturesKHR*" : "VkPhysicalDeviceShaderQuadControlFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
            dump_VkSurfaceProtectedCapabilitiesKHR<Format>(*reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceProtectedCapabilitiesKHR*" : "VkSurfaceProtectedCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
            dump_VkPhysicalDevicePresentWaitFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentWaitFeaturesKHR*" : "VkPhysicalDevicePresentWaitFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
            dump_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*" : "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR:
            dump_VkPipelineInfoKHR<Format>(*reinterpret_cast<const VkPipelineInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineInfoKHR*" : "VkPipelineInfoKHR"), "pNext", indents, reinterpret_cast<const VkPipelineInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR:
            dump_VkPipelineExecutablePropertiesKHR<Format>(*reinterpret_cast<const VkPipelineExecutablePropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineExecutablePropertiesKHR*" : "VkPipelineExecutablePropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPipelineExecutablePropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR:
            dump_VkPipelineExecutableInfoKHR<Format>(*reinterpret_cast<const VkPipelineExecutableInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineExecutableInfoKHR*" : "VkPipelineExecutableInfoKHR"), "pNext", indents, reinterpret_cast<const VkPipelineExecutableInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR:
            dump_VkPipelineExecutableStatisticKHR<Format>(*reinterpret_cast<const VkPipelineExecutableStatisticKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineExecutableStatisticKHR*" : "VkPipelineExecutableStatisticKHR"), "pNext", indents, reinterpret_cast<const VkPipelineExecutableStatisticKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR:
            dump_VkPipelineExecutableInternalRepresentationKHR<Format>(*reinterpret_cast<const VkPipelineExecutableInternalRepresentationKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineExecutableInternalRepresentationKHR*" : "VkPipelineExecutableInternalRepresentationKHR"), "pNext", indents, reinterpret_cast<const VkPipelineExecutableInternalRepresentationKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
            dump_VkPipelineLibraryCreateInfoKHR<Format>(*reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineLibraryCreateInfoKHR*" : "VkPipelineLibraryCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
            dump_VkPresentIdKHR<Format>(*reinterpret_cast<const VkPresentIdKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentIdKHR*" : "VkPresentIdKHR"), "pNext", indents, reinterpret_cast<const VkPresentIdKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
            dump_VkPhysicalDevicePresentIdFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentIdFeaturesKHR*" : "VkPhysicalDevicePresentIdFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR:
            dump_VkVideoEncodeInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeInfoKHR*" : "VkVideoEncodeInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
            dump_VkVideoEncodeCapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeCapabilitiesKHR*" : "VkVideoEncodeCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
            dump_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR<Format>(*reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*" : "VkQueryPoolVideoEncodeFeedbackCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
            dump_VkVideoEncodeUsageInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeUsageInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeUsageInfoKHR*" : "VkVideoEncodeUsageInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeUsageInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR:
            dump_VkVideoEncodeRateControlLayerInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeRateControlLayerInfoKHR*" : "VkVideoEncodeRateControlLayerInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
            dump_VkVideoEncodeRateControlInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeRateControlInfoKHR*" : "VkVideoEncodeRateControlInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
            dump_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*" : "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_VkVideoEncodeQualityLevelPropertiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeQualityLevelPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeQualityLevelPropertiesKHR*" : "VkVideoEncodeQualityLevelPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeQualityLevelPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
            dump_VkVideoEncodeQualityLevelInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeQualityLevelInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeQualityLevelInfoKHR*" : "VkVideoEncodeQualityLevelInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeQualityLevelInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR:
            dump_VkVideoEncodeSessionParametersGetInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeSessionParametersGetInfoKHR*" : "VkVideoEncodeSessionParametersGetInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
            dump_VkVideoEncodeSessionParametersFeedbackInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeSessionParametersFeedbackInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeSessionParametersFeedbackInfoKHR*" : "VkVideoEncodeSessionParametersFeedbackInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeSessionParametersFeedbackInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR:
            dump_VkDeviceMemoryCopyKHR<Format>(*reinterpret_cast<const VkDeviceMemoryCopyKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceMemoryCopyKHR*" : "VkDeviceMemoryCopyKHR"), "pNext", indents, reinterpret_cast<const VkDeviceMemoryCopyKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR:
            dump_VkCopyDeviceMemoryInfoKHR<Format>(*reinterpret_cast<const VkCopyDeviceMemoryInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyDeviceMemoryInfoKHR*" : "VkCopyDeviceMemoryInfoKHR"), "pNext", indents, reinterpret_cast<const VkCopyDeviceMemoryInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR:
            dump_VkDeviceMemoryImageCopyKHR<Format>(*reinterpret_cast<const VkDeviceMemoryImageCopyKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceMemoryImageCopyKHR*" : "VkDeviceMemoryImageCopyKHR"), "pNext", indents, reinterpret_cast<const VkDeviceMemoryImageCopyKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR:
            dump_VkCopyDeviceMemoryImageInfoKHR<Format>(*reinterpret_cast<const VkCopyDeviceMemoryImageInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyDeviceMemoryImageInfoKHR*" : "VkCopyDeviceMemoryImageInfoKHR"), "pNext", indents, reinterpret_cast<const VkCopyDeviceMemoryImageInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR:
            dump_VkMemoryRangeBarrierKHR<Format>(*reinterpret_cast<const VkMemoryRangeBarrierKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryRangeBarrierKHR*" : "VkMemoryRangeBarrierKHR"), "pNext", indents, reinterpret_cast<const VkMemoryRangeBarrierKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR:
            dump_VkMemoryRangeBarriersInfoKHR<Format>(*reinterpret_cast<const VkMemoryRangeBarriersInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryRangeBarriersInfoKHR*" : "VkMemoryRangeBarriersInfoKHR"), "pNext", indents, reinterpret_cast<const VkMemoryRangeBarriersInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR:
            dump_VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR*" : "VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR:
            dump_VkBindIndexBuffer3InfoKHR<Format>(*reinterpret_cast<const VkBindIndexBuffer3InfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindIndexBuffer3InfoKHR*" : "VkBindIndexBuffer3InfoKHR"), "pNext", indents, reinterpret_cast<const VkBindIndexBuffer3InfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR:
            dump_VkBindVertexBuffer3InfoKHR<Format>(*reinterpret_cast<const VkBindVertexBuffer3InfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindVertexBuffer3InfoKHR*" : "VkBindVertexBuffer3InfoKHR"), "pNext", indents, reinterpret_cast<const VkBindVertexBuffer3InfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR:
            dump_VkDrawIndirect2InfoKHR<Format>(*reinterpret_cast<const VkDrawIndirect2InfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDrawIndirect2InfoKHR*" : "VkDrawIndirect2InfoKHR"), "pNext", indents, reinterpret_cast<const VkDrawIndirect2InfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR:
            dump_VkDrawIndirectCount2InfoKHR<Format>(*reinterpret_cast<const VkDrawIndirectCount2InfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDrawIndirectCount2InfoKHR*" : "VkDrawIndirectCount2InfoKHR"), "pNext", indents, reinterpret_cast<const VkDrawIndirectCount2InfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR:
            dump_VkDispatchIndirect2InfoKHR<Format>(*reinterpret_cast<const VkDispatchIndirect2InfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDispatchIndirect2InfoKHR*" : "VkDispatchIndirect2InfoKHR"), "pNext", indents, reinterpret_cast<const VkDispatchIndirect2InfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT:
            dump_VkConditionalRenderingBeginInfo2EXT<Format>(*reinterpret_cast<const VkConditionalRenderingBeginInfo2EXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkConditionalRenderingBeginInfo2EXT*" : "VkConditionalRenderingBeginInfo2EXT"), "pNext", indents, reinterpret_cast<const VkConditionalRenderingBeginInfo2EXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT:
            dump_VkBindTransformFeedbackBuffer2InfoEXT<Format>(*reinterpret_cast<const VkBindTransformFeedbackBuffer2InfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindTransformFeedbackBuffer2InfoEXT*" : "VkBindTransformFeedbackBuffer2InfoEXT"), "pNext", indents, reinterpret_cast<const VkBindTransformFeedbackBuffer2InfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD:
            dump_VkMemoryMarkerInfoAMD<Format>(*reinterpret_cast<const VkMemoryMarkerInfoAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryMarkerInfoAMD*" : "VkMemoryMarkerInfoAMD"), "pNext", indents, reinterpret_cast<const VkMemoryMarkerInfoAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR:
            dump_VkAccelerationStructureCreateInfo2KHR<Format>(*reinterpret_cast<const VkAccelerationStructureCreateInfo2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureCreateInfo2KHR*" : "VkAccelerationStructureCreateInfo2KHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureCreateInfo2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
            dump_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*" : "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
            dump_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*" : "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
            dump_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*" : "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
            dump_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*" : "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
            dump_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*" : "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR:
            dump_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*" : "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
            dump_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*" : "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR:
            dump_VkSurfaceCapabilitiesPresentId2KHR<Format>(*reinterpret_cast<const VkSurfaceCapabilitiesPresentId2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilitiesPresentId2KHR*" : "VkSurfaceCapabilitiesPresentId2KHR"), "pNext", indents, reinterpret_cast<const VkSurfaceCapabilitiesPresentId2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR:
            dump_VkPresentId2KHR<Format>(*reinterpret_cast<const VkPresentId2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentId2KHR*" : "VkPresentId2KHR"), "pNext", indents, reinterpret_cast<const VkPresentId2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
            dump_VkPhysicalDevicePresentId2FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentId2FeaturesKHR*" : "VkPhysicalDevicePresentId2FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR:
            dump_VkSurfaceCapabilitiesPresentWait2KHR<Format>(*reinterpret_cast<const VkSurfaceCapabilitiesPresentWait2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilitiesPresentWait2KHR*" : "VkSurfaceCapabilitiesPresentWait2KHR"), "pNext", indents, reinterpret_cast<const VkSurfaceCapabilitiesPresentWait2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
            dump_VkPhysicalDevicePresentWait2FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentWait2FeaturesKHR*" : "VkPhysicalDevicePresentWait2FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR:
            dump_VkPresentWait2InfoKHR<Format>(*reinterpret_cast<const VkPresentWait2InfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentWait2InfoKHR*" : "VkPresentWait2InfoKHR"), "pNext", indents, reinterpret_cast<const VkPresentWait2InfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
            dump_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*" : "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
            dump_VkPhysicalDevicePipelineBinaryFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineBinaryFeaturesKHR*" : "VkPhysicalDevicePipelineBinaryFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
            dump_VkPhysicalDevicePipelineBinaryPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePipelineBinaryPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineBinaryPropertiesKHR*" : "VkPhysicalDevicePipelineBinaryPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePipelineBinaryPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
            dump_VkDevicePipelineBinaryInternalCacheControlKHR<Format>(*reinterpret_cast<const VkDevicePipelineBinaryInternalCacheControlKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDevicePipelineBinaryInternalCacheControlKHR*" : "VkDevicePipelineBinaryInternalCacheControlKHR"), "pNext", indents, reinterpret_cast<const VkDevicePipelineBinaryInternalCacheControlKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR:
            dump_VkPipelineBinaryKeyKHR<Format>(*reinterpret_cast<const VkPipelineBinaryKeyKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineBinaryKeyKHR*" : "VkPipelineBinaryKeyKHR"), "pNext", indents, reinterpret_cast<const VkPipelineBinaryKeyKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR:
            dump_VkPipelineCreateInfoKHR<Format>(*reinterpret_cast<const VkPipelineCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCreateInfoKHR*" : "VkPipelineCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkPipelineCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR:
            dump_VkPipelineBinaryCreateInfoKHR<Format>(*reinterpret_cast<const VkPipelineBinaryCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineBinaryCreateInfoKHR*" : "VkPipelineBinaryCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkPipelineBinaryCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
            dump_VkPipelineBinaryInfoKHR<Format>(*reinterpret_cast<const VkPipelineBinaryInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineBinaryInfoKHR*" : "VkPipelineBinaryInfoKHR"), "pNext", indents, reinterpret_cast<const VkPipelineBinaryInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR:
            dump_VkReleaseCapturedPipelineDataInfoKHR<Format>(*reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkReleaseCapturedPipelineDataInfoKHR*" : "VkReleaseCapturedPipelineDataInfoKHR"), "pNext", indents, reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR:
            dump_VkPipelineBinaryDataInfoKHR<Format>(*reinterpret_cast<const VkPipelineBinaryDataInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineBinaryDataInfoKHR*" : "VkPipelineBinaryDataInfoKHR"), "pNext", indents, reinterpret_cast<const VkPipelineBinaryDataInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR:
            dump_VkPipelineBinaryHandlesInfoKHR<Format>(*reinterpret_cast<const VkPipelineBinaryHandlesInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineBinaryHandlesInfoKHR*" : "VkPipelineBinaryHandlesInfoKHR"), "pNext", indents, reinterpret_cast<const VkPipelineBinaryHandlesInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR:
            dump_VkSurfacePresentModeKHR<Format>(*reinterpret_cast<const VkSurfacePresentModeKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfacePresentModeKHR*" : "VkSurfacePresentModeKHR"), "pNext", indents, reinterpret_cast<const VkSurfacePresentModeKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR:
            dump_VkSurfacePresentScalingCapabilitiesKHR<Format>(*reinterpret_cast<const VkSurfacePresentScalingCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfacePresentScalingCapabilitiesKHR*" : "VkSurfacePresentScalingCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkSurfacePresentScalingCapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR:
            dump_VkSurfacePresentModeCompatibilityKHR<Format>(*reinterpret_cast<const VkSurfacePresentModeCompatibilityKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfacePresentModeCompatibilityKHR*" : "VkSurfacePresentModeCompatibilityKHR"), "pNext", indents, reinterpret_cast<const VkSurfacePresentModeCompatibilityKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR:
            dump_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*" : "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR:
            dump_VkSwapchainPresentFenceInfoKHR<Format>(*reinterpret_cast<const VkSwapchainPresentFenceInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainPresentFenceInfoKHR*" : "VkSwapchainPresentFenceInfoKHR"), "pNext", indents, reinterpret_cast<const VkSwapchainPresentFenceInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR:
            dump_VkSwapchainPresentModesCreateInfoKHR<Format>(*reinterpret_cast<const VkSwapchainPresentModesCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainPresentModesCreateInfoKHR*" : "VkSwapchainPresentModesCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkSwapchainPresentModesCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR:
            dump_VkSwapchainPresentModeInfoKHR<Format>(*reinterpret_cast<const VkSwapchainPresentModeInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainPresentModeInfoKHR*" : "VkSwapchainPresentModeInfoKHR"), "pNext", indents, reinterpret_cast<const VkSwapchainPresentModeInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR:
            dump_VkSwapchainPresentScalingCreateInfoKHR<Format>(*reinterpret_cast<const VkSwapchainPresentScalingCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainPresentScalingCreateInfoKHR*" : "VkSwapchainPresentScalingCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkSwapchainPresentScalingCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR:
            dump_VkReleaseSwapchainImagesInfoKHR<Format>(*reinterpret_cast<const VkReleaseSwapchainImagesInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkReleaseSwapchainImagesInfoKHR*" : "VkReleaseSwapchainImagesInfoKHR"), "pNext", indents, reinterpret_cast<const VkReleaseSwapchainImagesInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR:
            dump_VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*" : "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
            dump_VkCooperativeMatrixPropertiesKHR<Format>(*reinterpret_cast<const VkCooperativeMatrixPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCooperativeMatrixPropertiesKHR*" : "VkCooperativeMatrixPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkCooperativeMatrixPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
            dump_VkPhysicalDeviceCooperativeMatrixFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixFeaturesKHR*" : "VkPhysicalDeviceCooperativeMatrixFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
            dump_VkPhysicalDeviceCooperativeMatrixPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixPropertiesKHR*" : "VkPhysicalDeviceCooperativeMatrixPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
            dump_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*" : "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
            dump_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR*" : "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
            dump_VkVideoDecodeAV1ProfileInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeAV1ProfileInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1ProfileInfoKHR*" : "VkVideoDecodeAV1ProfileInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeAV1ProfileInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
            dump_VkVideoDecodeAV1CapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoDecodeAV1CapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1CapabilitiesKHR*" : "VkVideoDecodeAV1CapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeAV1CapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_VkVideoDecodeAV1SessionParametersCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeAV1SessionParametersCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1SessionParametersCreateInfoKHR*" : "VkVideoDecodeAV1SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeAV1SessionParametersCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
            dump_VkVideoDecodeAV1PictureInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeAV1PictureInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1PictureInfoKHR*" : "VkVideoDecodeAV1PictureInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeAV1PictureInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
            dump_VkVideoDecodeAV1DpbSlotInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeAV1DpbSlotInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1DpbSlotInfoKHR*" : "VkVideoDecodeAV1DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeAV1DpbSlotInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
            dump_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*" : "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
            dump_VkVideoEncodeAV1CapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeAV1CapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1CapabilitiesKHR*" : "VkVideoEncodeAV1CapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeAV1CapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
            dump_VkVideoEncodeAV1QualityLevelPropertiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeAV1QualityLevelPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1QualityLevelPropertiesKHR*" : "VkVideoEncodeAV1QualityLevelPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeAV1QualityLevelPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
            dump_VkVideoEncodeAV1SessionCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeAV1SessionCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1SessionCreateInfoKHR*" : "VkVideoEncodeAV1SessionCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeAV1SessionCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_VkVideoEncodeAV1SessionParametersCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeAV1SessionParametersCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1SessionParametersCreateInfoKHR*" : "VkVideoEncodeAV1SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeAV1SessionParametersCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
            dump_VkVideoEncodeAV1PictureInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeAV1PictureInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1PictureInfoKHR*" : "VkVideoEncodeAV1PictureInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeAV1PictureInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
            dump_VkVideoEncodeAV1DpbSlotInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeAV1DpbSlotInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1DpbSlotInfoKHR*" : "VkVideoEncodeAV1DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeAV1DpbSlotInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
            dump_VkVideoEncodeAV1ProfileInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeAV1ProfileInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1ProfileInfoKHR*" : "VkVideoEncodeAV1ProfileInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeAV1ProfileInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
            dump_VkVideoEncodeAV1GopRemainingFrameInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeAV1GopRemainingFrameInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1GopRemainingFrameInfoKHR*" : "VkVideoEncodeAV1GopRemainingFrameInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeAV1GopRemainingFrameInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
            dump_VkVideoEncodeAV1RateControlInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeAV1RateControlInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1RateControlInfoKHR*" : "VkVideoEncodeAV1RateControlInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeAV1RateControlInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
            dump_VkVideoEncodeAV1RateControlLayerInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeAV1RateControlLayerInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1RateControlLayerInfoKHR*" : "VkVideoEncodeAV1RateControlLayerInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeAV1RateControlLayerInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
            dump_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*" : "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
            dump_VkVideoDecodeVP9ProfileInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeVP9ProfileInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeVP9ProfileInfoKHR*" : "VkVideoDecodeVP9ProfileInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeVP9ProfileInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR:
            dump_VkVideoDecodeVP9CapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoDecodeVP9CapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeVP9CapabilitiesKHR*" : "VkVideoDecodeVP9CapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeVP9CapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR:
            dump_VkVideoDecodeVP9PictureInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeVP9PictureInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeVP9PictureInfoKHR*" : "VkVideoDecodeVP9PictureInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeVP9PictureInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
            dump_VkPhysicalDeviceVideoMaintenance1FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoMaintenance1FeaturesKHR*" : "VkPhysicalDeviceVideoMaintenance1FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
            dump_VkVideoInlineQueryInfoKHR<Format>(*reinterpret_cast<const VkVideoInlineQueryInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoInlineQueryInfoKHR*" : "VkVideoInlineQueryInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoInlineQueryInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
            dump_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*" : "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
            dump_VkAttachmentFeedbackLoopInfoEXT<Format>(*reinterpret_cast<const VkAttachmentFeedbackLoopInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentFeedbackLoopInfoEXT*" : "VkAttachmentFeedbackLoopInfoEXT"), "pNext", indents, reinterpret_cast<const VkAttachmentFeedbackLoopInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR:
            dump_VkCalibratedTimestampInfoKHR<Format>(*reinterpret_cast<const VkCalibratedTimestampInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCalibratedTimestampInfoKHR*" : "VkCalibratedTimestampInfoKHR"), "pNext", indents, reinterpret_cast<const VkCalibratedTimestampInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT:
            dump_VkSetDescriptorBufferOffsetsInfoEXT<Format>(*reinterpret_cast<const VkSetDescriptorBufferOffsetsInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSetDescriptorBufferOffsetsInfoEXT*" : "VkSetDescriptorBufferOffsetsInfoEXT"), "pNext", indents, reinterpret_cast<const VkSetDescriptorBufferOffsetsInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT:
            dump_VkBindDescriptorBufferEmbeddedSamplersInfoEXT<Format>(*reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindDescriptorBufferEmbeddedSamplersInfoEXT*" : "VkBindDescriptorBufferEmbeddedSamplersInfoEXT"), "pNext", indents, reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR:
            dump_VkCopyMemoryIndirectInfoKHR<Format>(*reinterpret_cast<const VkCopyMemoryIndirectInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMemoryIndirectInfoKHR*" : "VkCopyMemoryIndirectInfoKHR"), "pNext", indents, reinterpret_cast<const VkCopyMemoryIndirectInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR:
            dump_VkCopyMemoryToImageIndirectInfoKHR<Format>(*reinterpret_cast<const VkCopyMemoryToImageIndirectInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMemoryToImageIndirectInfoKHR*" : "VkCopyMemoryToImageIndirectInfoKHR"), "pNext", indents, reinterpret_cast<const VkCopyMemoryToImageIndirectInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR:
            dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*" : "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR:
            dump_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR*" : "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR:
            dump_VkVideoEncodeIntraRefreshCapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeIntraRefreshCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeIntraRefreshCapabilitiesKHR*" : "VkVideoEncodeIntraRefreshCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeIntraRefreshCapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR:
            dump_VkVideoEncodeSessionIntraRefreshCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeSessionIntraRefreshCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeSessionIntraRefreshCreateInfoKHR*" : "VkVideoEncodeSessionIntraRefreshCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeSessionIntraRefreshCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR:
            dump_VkVideoEncodeIntraRefreshInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeIntraRefreshInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeIntraRefreshInfoKHR*" : "VkVideoEncodeIntraRefreshInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeIntraRefreshInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR:
            dump_VkVideoReferenceIntraRefreshInfoKHR<Format>(*reinterpret_cast<const VkVideoReferenceIntraRefreshInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoReferenceIntraRefreshInfoKHR*" : "VkVideoReferenceIntraRefreshInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoReferenceIntraRefreshInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR:
            dump_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*" : "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_VkVideoEncodeQuantizationMapCapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeQuantizationMapCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeQuantizationMapCapabilitiesKHR*" : "VkVideoEncodeQuantizationMapCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeQuantizationMapCapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
            dump_VkVideoFormatQuantizationMapPropertiesKHR<Format>(*reinterpret_cast<const VkVideoFormatQuantizationMapPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoFormatQuantizationMapPropertiesKHR*" : "VkVideoFormatQuantizationMapPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoFormatQuantizationMapPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
            dump_VkVideoEncodeQuantizationMapInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeQuantizationMapInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeQuantizationMapInfoKHR*" : "VkVideoEncodeQuantizationMapInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeQuantizationMapInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
            dump_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR<Format>(*reinterpret_cast<const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR*" : "VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
            dump_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*" : "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_VkVideoEncodeH264QuantizationMapCapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeH264QuantizationMapCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264QuantizationMapCapabilitiesKHR*" : "VkVideoEncodeH264QuantizationMapCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH264QuantizationMapCapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_VkVideoEncodeH265QuantizationMapCapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeH265QuantizationMapCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265QuantizationMapCapabilitiesKHR*" : "VkVideoEncodeH265QuantizationMapCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeH265QuantizationMapCapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
            dump_VkVideoFormatH265QuantizationMapPropertiesKHR<Format>(*reinterpret_cast<const VkVideoFormatH265QuantizationMapPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoFormatH265QuantizationMapPropertiesKHR*" : "VkVideoFormatH265QuantizationMapPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoFormatH265QuantizationMapPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
            dump_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR*" : "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
            dump_VkVideoFormatAV1QuantizationMapPropertiesKHR<Format>(*reinterpret_cast<const VkVideoFormatAV1QuantizationMapPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoFormatAV1QuantizationMapPropertiesKHR*" : "VkVideoFormatAV1QuantizationMapPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoFormatAV1QuantizationMapPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
            dump_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*" : "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR:
            dump_VkPhysicalDeviceMaintenance7FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance7FeaturesKHR*" : "VkPhysicalDeviceMaintenance7FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR:
            dump_VkPhysicalDeviceMaintenance7PropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance7PropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance7PropertiesKHR*" : "VkPhysicalDeviceMaintenance7PropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance7PropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR:
            dump_VkPhysicalDeviceLayeredApiPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceLayeredApiPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLayeredApiPropertiesKHR*" : "VkPhysicalDeviceLayeredApiPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceLayeredApiPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR:
            dump_VkPhysicalDeviceLayeredApiPropertiesListKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceLayeredApiPropertiesListKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLayeredApiPropertiesListKHR*" : "VkPhysicalDeviceLayeredApiPropertiesListKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceLayeredApiPropertiesListKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR:
            dump_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR*" : "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR:
            dump_VkPhysicalDeviceFaultFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceFaultFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFaultFeaturesKHR*" : "VkPhysicalDeviceFaultFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFaultFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR:
            dump_VkPhysicalDeviceFaultPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceFaultPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFaultPropertiesKHR*" : "VkPhysicalDeviceFaultPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFaultPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR:
            dump_VkDeviceFaultInfoKHR<Format>(*reinterpret_cast<const VkDeviceFaultInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceFaultInfoKHR*" : "VkDeviceFaultInfoKHR"), "pNext", indents, reinterpret_cast<const VkDeviceFaultInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR:
            dump_VkDeviceFaultDebugInfoKHR<Format>(*reinterpret_cast<const VkDeviceFaultDebugInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceFaultDebugInfoKHR*" : "VkDeviceFaultDebugInfoKHR"), "pNext", indents, reinterpret_cast<const VkDeviceFaultDebugInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
            dump_VkMemoryBarrierAccessFlags3KHR<Format>(*reinterpret_cast<const VkMemoryBarrierAccessFlags3KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryBarrierAccessFlags3KHR*" : "VkMemoryBarrierAccessFlags3KHR"), "pNext", indents, reinterpret_cast<const VkMemoryBarrierAccessFlags3KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
            dump_VkPhysicalDeviceMaintenance8FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance8FeaturesKHR*" : "VkPhysicalDeviceMaintenance8FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR:
            dump_VkPhysicalDeviceShaderFmaFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderFmaFeaturesKHR*" : "VkPhysicalDeviceShaderFmaFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
            dump_VkPhysicalDeviceMaintenance9FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance9FeaturesKHR*" : "VkPhysicalDeviceMaintenance9FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
            dump_VkPhysicalDeviceMaintenance9PropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance9PropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance9PropertiesKHR*" : "VkPhysicalDeviceMaintenance9PropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance9PropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
            dump_VkQueueFamilyOwnershipTransferPropertiesKHR<Format>(*reinterpret_cast<const VkQueueFamilyOwnershipTransferPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyOwnershipTransferPropertiesKHR*" : "VkQueueFamilyOwnershipTransferPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkQueueFamilyOwnershipTransferPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
            dump_VkPhysicalDeviceVideoMaintenance2FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoMaintenance2FeaturesKHR*" : "VkPhysicalDeviceVideoMaintenance2FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR:
            dump_VkVideoDecodeH264InlineSessionParametersInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH264InlineSessionParametersInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264InlineSessionParametersInfoKHR*" : "VkVideoDecodeH264InlineSessionParametersInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH264InlineSessionParametersInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR:
            dump_VkVideoDecodeH265InlineSessionParametersInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeH265InlineSessionParametersInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265InlineSessionParametersInfoKHR*" : "VkVideoDecodeH265InlineSessionParametersInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeH265InlineSessionParametersInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR:
            dump_VkVideoDecodeAV1InlineSessionParametersInfoKHR<Format>(*reinterpret_cast<const VkVideoDecodeAV1InlineSessionParametersInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1InlineSessionParametersInfoKHR*" : "VkVideoDecodeAV1InlineSessionParametersInfoKHR"), "pNext", indents, reinterpret_cast<const VkVideoDecodeAV1InlineSessionParametersInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR:
            dump_VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR*" : "VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR:
            dump_VkVideoEncodeFeedback2CapabilitiesKHR<Format>(*reinterpret_cast<const VkVideoEncodeFeedback2CapabilitiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeFeedback2CapabilitiesKHR*" : "VkVideoEncodeFeedback2CapabilitiesKHR"), "pNext", indents, reinterpret_cast<const VkVideoEncodeFeedback2CapabilitiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_CREATE_INFO_KHR:
            dump_VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR<Format>(*reinterpret_cast<const VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR*" : "VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
            dump_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*" : "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
            dump_VkPhysicalDeviceRobustness2FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRobustness2FeaturesKHR*" : "VkPhysicalDeviceRobustness2FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
            dump_VkPhysicalDeviceRobustness2PropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRobustness2PropertiesKHR*" : "VkPhysicalDeviceRobustness2PropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR:
            dump_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*" : "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR:
            dump_VkAccelerationStructureGeometryMicromapDataKHR<Format>(*reinterpret_cast<const VkAccelerationStructureGeometryMicromapDataKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryMicromapDataKHR*" : "VkAccelerationStructureGeometryMicromapDataKHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureGeometryMicromapDataKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR:
            dump_VkPhysicalDeviceOpacityMicromapFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceOpacityMicromapFeaturesKHR*" : "VkPhysicalDeviceOpacityMicromapFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR:
            dump_VkPhysicalDeviceOpacityMicromapPropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceOpacityMicromapPropertiesKHR*" : "VkPhysicalDeviceOpacityMicromapPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR:
            dump_VkAccelerationStructureTrianglesOpacityMicromapKHR<Format>(*reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureTrianglesOpacityMicromapKHR*" : "VkAccelerationStructureTrianglesOpacityMicromapKHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR:
            dump_VkPhysicalDeviceMaintenance10FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance10FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance10FeaturesKHR*" : "VkPhysicalDeviceMaintenance10FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance10FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR:
            dump_VkPhysicalDeviceMaintenance10PropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance10PropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance10PropertiesKHR*" : "VkPhysicalDeviceMaintenance10PropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance10PropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR:
            dump_VkRenderingEndInfoKHR<Format>(*reinterpret_cast<const VkRenderingEndInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingEndInfoKHR*" : "VkRenderingEndInfoKHR"), "pNext", indents, reinterpret_cast<const VkRenderingEndInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR:
            dump_VkRenderingAttachmentFlagsInfoKHR<Format>(*reinterpret_cast<const VkRenderingAttachmentFlagsInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingAttachmentFlagsInfoKHR*" : "VkRenderingAttachmentFlagsInfoKHR"), "pNext", indents, reinterpret_cast<const VkRenderingAttachmentFlagsInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR:
            dump_VkResolveImageModeInfoKHR<Format>(*reinterpret_cast<const VkResolveImageModeInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkResolveImageModeInfoKHR*" : "VkResolveImageModeInfoKHR"), "pNext", indents, reinterpret_cast<const VkResolveImageModeInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR:
            dump_VkPhysicalDeviceMaintenance11FeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceMaintenance11FeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance11FeaturesKHR*" : "VkPhysicalDeviceMaintenance11FeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMaintenance11FeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR:
            dump_VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR<Format>(*reinterpret_cast<const VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR*" : "VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR"), "pNext", indents, reinterpret_cast<const VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR:
            dump_VkFormatProperties4KHR<Format>(*reinterpret_cast<const VkFormatProperties4KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFormatProperties4KHR*" : "VkFormatProperties4KHR"), "pNext", indents, reinterpret_cast<const VkFormatProperties4KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR:
            dump_VkImageUsageFlags2CreateInfoKHR<Format>(*reinterpret_cast<const VkImageUsageFlags2CreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageUsageFlags2CreateInfoKHR*" : "VkImageUsageFlags2CreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkImageUsageFlags2CreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR:
            dump_VkImageCreateFlags2CreateInfoKHR<Format>(*reinterpret_cast<const VkImageCreateFlags2CreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageCreateFlags2CreateInfoKHR*" : "VkImageCreateFlags2CreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkImageCreateFlags2CreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR:
            dump_VkImageViewUsage2CreateInfoKHR<Format>(*reinterpret_cast<const VkImageViewUsage2CreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewUsage2CreateInfoKHR*" : "VkImageViewUsage2CreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkImageViewUsage2CreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR:
            dump_VkPhysicalDeviceExtendedFlagsFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceExtendedFlagsFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedFlagsFeaturesKHR*" : "VkPhysicalDeviceExtendedFlagsFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExtendedFlagsFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR:
            dump_VkImageStencilUsage2CreateInfoKHR<Format>(*reinterpret_cast<const VkImageStencilUsage2CreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageStencilUsage2CreateInfoKHR*" : "VkImageStencilUsage2CreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkImageStencilUsage2CreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR:
            dump_VkSharedPresentSurfaceCapabilities2KHR<Format>(*reinterpret_cast<const VkSharedPresentSurfaceCapabilities2KHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSharedPresentSurfaceCapabilities2KHR*" : "VkSharedPresentSurfaceCapabilities2KHR"), "pNext", indents, reinterpret_cast<const VkSharedPresentSurfaceCapabilities2KHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
            dump_VkDebugReportCallbackCreateInfoEXT<Format>(*reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugReportCallbackCreateInfoEXT*" : "VkDebugReportCallbackCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
            dump_VkPipelineRasterizationStateRasterizationOrderAMD<Format>(*reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationStateRasterizationOrderAMD*" : "VkPipelineRasterizationStateRasterizationOrderAMD"), "pNext", indents, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
            dump_VkDebugMarkerObjectNameInfoEXT<Format>(*reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugMarkerObjectNameInfoEXT*" : "VkDebugMarkerObjectNameInfoEXT"), "pNext", indents, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
            dump_VkDebugMarkerObjectTagInfoEXT<Format>(*reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugMarkerObjectTagInfoEXT*" : "VkDebugMarkerObjectTagInfoEXT"), "pNext", indents, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT:
            dump_VkDebugMarkerMarkerInfoEXT<Format>(*reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugMarkerMarkerInfoEXT*" : "VkDebugMarkerMarkerInfoEXT"), "pNext", indents, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
            dump_VkDedicatedAllocationImageCreateInfoNV<Format>(*reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDedicatedAllocationImageCreateInfoNV*" : "VkDedicatedAllocationImageCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
            dump_VkDedicatedAllocationBufferCreateInfoNV<Format>(*reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDedicatedAllocationBufferCreateInfoNV*" : "VkDedicatedAllocationBufferCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
            dump_VkDedicatedAllocationMemoryAllocateInfoNV<Format>(*reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDedicatedAllocationMemoryAllocateInfoNV*" : "VkDedicatedAllocationMemoryAllocateInfoNV"), "pNext", indents, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
            dump_VkPhysicalDeviceTransformFeedbackFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTransformFeedbackFeaturesEXT*" : "VkPhysicalDeviceTransformFeedbackFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
            dump_VkPhysicalDeviceTransformFeedbackPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTransformFeedbackPropertiesEXT*" : "VkPhysicalDeviceTransformFeedbackPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
            dump_VkPipelineRasterizationStateStreamCreateInfoEXT<Format>(*reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationStateStreamCreateInfoEXT*" : "VkPipelineRasterizationStateStreamCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX:
            dump_VkCuModuleCreateInfoNVX<Format>(*reinterpret_cast<const VkCuModuleCreateInfoNVX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCuModuleCreateInfoNVX*" : "VkCuModuleCreateInfoNVX"), "pNext", indents, reinterpret_cast<const VkCuModuleCreateInfoNVX*>(object));
            break;

        case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
            dump_VkCuModuleTexturingModeCreateInfoNVX<Format>(*reinterpret_cast<const VkCuModuleTexturingModeCreateInfoNVX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCuModuleTexturingModeCreateInfoNVX*" : "VkCuModuleTexturingModeCreateInfoNVX"), "pNext", indents, reinterpret_cast<const VkCuModuleTexturingModeCreateInfoNVX*>(object));
            break;

        case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX:
            dump_VkCuFunctionCreateInfoNVX<Format>(*reinterpret_cast<const VkCuFunctionCreateInfoNVX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCuFunctionCreateInfoNVX*" : "VkCuFunctionCreateInfoNVX"), "pNext", indents, reinterpret_cast<const VkCuFunctionCreateInfoNVX*>(object));
            break;

        case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX:
            dump_VkCuLaunchInfoNVX<Format>(*reinterpret_cast<const VkCuLaunchInfoNVX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCuLaunchInfoNVX*" : "VkCuLaunchInfoNVX"), "pNext", indents, reinterpret_cast<const VkCuLaunchInfoNVX*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX:
            dump_VkImageViewHandleInfoNVX<Format>(*reinterpret_cast<const VkImageViewHandleInfoNVX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewHandleInfoNVX*" : "VkImageViewHandleInfoNVX"), "pNext", indents, reinterpret_cast<const VkImageViewHandleInfoNVX*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX:
            dump_VkImageViewAddressPropertiesNVX<Format>(*reinterpret_cast<const VkImageViewAddressPropertiesNVX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewAddressPropertiesNVX*" : "VkImageViewAddressPropertiesNVX"), "pNext", indents, reinterpret_cast<const VkImageViewAddressPropertiesNVX*>(object));
            break;

        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
            dump_VkTextureLODGatherFormatPropertiesAMD<Format>(*reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTextureLODGatherFormatPropertiesAMD*" : "VkTextureLODGatherFormatPropertiesAMD"), "pNext", indents, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(object));
            break;
#if defined(VK_USE_PLATFORM_GGP)

        case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP:
            dump_VkStreamDescriptorSurfaceCreateInfoGGP<Format>(*reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>(object), settings, (Format == ApiDumpFormat::Json ? "VkStreamDescriptorSurfaceCreateInfoGGP*" : "VkStreamDescriptorSurfaceCreateInfoGGP"), "pNext", indents, reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>(object));
            break;
#endif  // VK_USE_PLATFORM_GGP

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
            dump_VkPhysicalDeviceCornerSampledImageFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCornerSampledImageFeaturesNV*" : "VkPhysicalDeviceCornerSampledImageFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
            dump_VkExternalMemoryImageCreateInfoNV<Format>(*reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalMemoryImageCreateInfoNV*" : "VkExternalMemoryImageCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
            dump_VkExportMemoryAllocateInfoNV<Format>(*reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMemoryAllocateInfoNV*" : "VkExportMemoryAllocateInfoNV"), "pNext", indents, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(object));
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
            dump_VkImportMemoryWin32HandleInfoNV<Format>(*reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryWin32HandleInfoNV*" : "VkImportMemoryWin32HandleInfoNV"), "pNext", indents, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
            dump_VkExportMemoryWin32HandleInfoNV<Format>(*reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMemoryWin32HandleInfoNV*" : "VkExportMemoryWin32HandleInfoNV"), "pNext", indents, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
            dump_VkWin32KeyedMutexAcquireReleaseInfoNV<Format>(*reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWin32KeyedMutexAcquireReleaseInfoNV*" : "VkWin32KeyedMutexAcquireReleaseInfoNV"), "pNext", indents, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(object));
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
            dump_VkValidationFlagsEXT<Format>(*reinterpret_cast<const VkValidationFlagsEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkValidationFlagsEXT*" : "VkValidationFlagsEXT"), "pNext", indents, reinterpret_cast<const VkValidationFlagsEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_VI_NN)

        case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN:
            dump_VkViSurfaceCreateInfoNN<Format>(*reinterpret_cast<const VkViSurfaceCreateInfoNN*>(object), settings, (Format == ApiDumpFormat::Json ? "VkViSurfaceCreateInfoNN*" : "VkViSurfaceCreateInfoNN"), "pNext", indents, reinterpret_cast<const VkViSurfaceCreateInfoNN*>(object));
            break;
#endif  // VK_USE_PLATFORM_VI_NN

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
            dump_VkImageViewASTCDecodeModeEXT<Format>(*reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewASTCDecodeModeEXT*" : "VkImageViewASTCDecodeModeEXT"), "pNext", indents, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
            dump_VkPhysicalDeviceASTCDecodeFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceASTCDecodeFeaturesEXT*" : "VkPhysicalDeviceASTCDecodeFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT:
            dump_VkConditionalRenderingBeginInfoEXT<Format>(*reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkConditionalRenderingBeginInfoEXT*" : "VkConditionalRenderingBeginInfoEXT"), "pNext", indents, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
            dump_VkPhysicalDeviceConditionalRenderingFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceConditionalRenderingFeaturesEXT*" : "VkPhysicalDeviceConditionalRenderingFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
            dump_VkCommandBufferInheritanceConditionalRenderingInfoEXT<Format>(*reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceConditionalRenderingInfoEXT*" : "VkCommandBufferInheritanceConditionalRenderingInfoEXT"), "pNext", indents, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
            dump_VkPipelineViewportWScalingStateCreateInfoNV<Format>(*reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportWScalingStateCreateInfoNV*" : "VkPipelineViewportWScalingStateCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT:
            dump_VkSurfaceCapabilities2EXT<Format>(*reinterpret_cast<const VkSurfaceCapabilities2EXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilities2EXT*" : "VkSurfaceCapabilities2EXT"), "pNext", indents, reinterpret_cast<const VkSurfaceCapabilities2EXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT:
            dump_VkDisplayPowerInfoEXT<Format>(*reinterpret_cast<const VkDisplayPowerInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayPowerInfoEXT*" : "VkDisplayPowerInfoEXT"), "pNext", indents, reinterpret_cast<const VkDisplayPowerInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT:
            dump_VkDeviceEventInfoEXT<Format>(*reinterpret_cast<const VkDeviceEventInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceEventInfoEXT*" : "VkDeviceEventInfoEXT"), "pNext", indents, reinterpret_cast<const VkDeviceEventInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT:
            dump_VkDisplayEventInfoEXT<Format>(*reinterpret_cast<const VkDisplayEventInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayEventInfoEXT*" : "VkDisplayEventInfoEXT"), "pNext", indents, reinterpret_cast<const VkDisplayEventInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
            dump_VkSwapchainCounterCreateInfoEXT<Format>(*reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainCounterCreateInfoEXT*" : "VkSwapchainCounterCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
            dump_VkPresentTimesInfoGOOGLE<Format>(*reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentTimesInfoGOOGLE*" : "VkPresentTimesInfoGOOGLE"), "pNext", indents, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
            dump_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<Format>(*reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*" : "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(object));
            break;

        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
            dump_VkMultiviewPerViewAttributesInfoNVX<Format>(*reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMultiviewPerViewAttributesInfoNVX*" : "VkMultiviewPerViewAttributesInfoNVX"), "pNext", indents, reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
            dump_VkPipelineViewportSwizzleStateCreateInfoNV<Format>(*reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportSwizzleStateCreateInfoNV*" : "VkPipelineViewportSwizzleStateCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
            dump_VkPhysicalDeviceDiscardRectanglePropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDiscardRectanglePropertiesEXT*" : "VkPhysicalDeviceDiscardRectanglePropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
            dump_VkPipelineDiscardRectangleStateCreateInfoEXT<Format>(*reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineDiscardRectangleStateCreateInfoEXT*" : "VkPipelineDiscardRectangleStateCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
            dump_VkPhysicalDeviceConservativeRasterizationPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceConservativeRasterizationPropertiesEXT*" : "VkPhysicalDeviceConservativeRasterizationPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
            dump_VkPipelineRasterizationConservativeStateCreateInfoEXT<Format>(*reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationConservativeStateCreateInfoEXT*" : "VkPipelineRasterizationConservativeStateCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
            dump_VkPhysicalDeviceDepthClipEnableFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthClipEnableFeaturesEXT*" : "VkPhysicalDeviceDepthClipEnableFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
            dump_VkPipelineRasterizationDepthClipStateCreateInfoEXT<Format>(*reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationDepthClipStateCreateInfoEXT*" : "VkPipelineRasterizationDepthClipStateCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_HDR_METADATA_EXT:
            dump_VkHdrMetadataEXT<Format>(*reinterpret_cast<const VkHdrMetadataEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkHdrMetadataEXT*" : "VkHdrMetadataEXT"), "pNext", indents, reinterpret_cast<const VkHdrMetadataEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
            dump_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG<Format>(*reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*" : "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(object));
            break;
#if defined(VK_USE_PLATFORM_IOS_MVK)

        case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK:
            dump_VkIOSSurfaceCreateInfoMVK<Format>(*reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>(object), settings, (Format == ApiDumpFormat::Json ? "VkIOSSurfaceCreateInfoMVK*" : "VkIOSSurfaceCreateInfoMVK"), "pNext", indents, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>(object));
            break;
#endif  // VK_USE_PLATFORM_IOS_MVK
#if defined(VK_USE_PLATFORM_MACOS_MVK)

        case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK:
            dump_VkMacOSSurfaceCreateInfoMVK<Format>(*reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMacOSSurfaceCreateInfoMVK*" : "VkMacOSSurfaceCreateInfoMVK"), "pNext", indents, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>(object));
            break;
#endif  // VK_USE_PLATFORM_MACOS_MVK

        case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT:
            dump_VkDebugUtilsLabelEXT<Format>(*reinterpret_cast<const VkDebugUtilsLabelEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugUtilsLabelEXT*" : "VkDebugUtilsLabelEXT"), "pNext", indents, reinterpret_cast<const VkDebugUtilsLabelEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
            dump_VkDebugUtilsObjectNameInfoEXT<Format>(*reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugUtilsObjectNameInfoEXT*" : "VkDebugUtilsObjectNameInfoEXT"), "pNext", indents, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
            dump_VkDebugUtilsMessengerCallbackDataEXT<Format>(*reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugUtilsMessengerCallbackDataEXT*" : "VkDebugUtilsMessengerCallbackDataEXT"), "pNext", indents, reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
            dump_VkDebugUtilsMessengerCreateInfoEXT<Format>(*reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugUtilsMessengerCreateInfoEXT*" : "VkDebugUtilsMessengerCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
            dump_VkDebugUtilsObjectTagInfoEXT<Format>(*reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugUtilsObjectTagInfoEXT*" : "VkDebugUtilsObjectTagInfoEXT"), "pNext", indents, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_ANDROID_KHR)

        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
            dump_VkAndroidHardwareBufferUsageANDROID<Format>(*reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidHardwareBufferUsageANDROID*" : "VkAndroidHardwareBufferUsageANDROID"), "pNext", indents, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(object));
            break;

        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
            dump_VkAndroidHardwareBufferPropertiesANDROID<Format>(*reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidHardwareBufferPropertiesANDROID*" : "VkAndroidHardwareBufferPropertiesANDROID"), "pNext", indents, reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>(object));
            break;

        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
            dump_VkAndroidHardwareBufferFormatPropertiesANDROID<Format>(*reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidHardwareBufferFormatPropertiesANDROID*" : "VkAndroidHardwareBufferFormatPropertiesANDROID"), "pNext", indents, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
            dump_VkImportAndroidHardwareBufferInfoANDROID<Format>(*reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportAndroidHardwareBufferInfoANDROID*" : "VkImportAndroidHardwareBufferInfoANDROID"), "pNext", indents, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
            dump_VkMemoryGetAndroidHardwareBufferInfoANDROID<Format>(*reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetAndroidHardwareBufferInfoANDROID*" : "VkMemoryGetAndroidHardwareBufferInfoANDROID"), "pNext", indents, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
            dump_VkExternalFormatANDROID<Format>(*reinterpret_cast<const VkExternalFormatANDROID*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalFormatANDROID*" : "VkExternalFormatANDROID"), "pNext", indents, reinterpret_cast<const VkExternalFormatANDROID*>(object));
            break;

        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
            dump_VkAndroidHardwareBufferFormatProperties2ANDROID<Format>(*reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidHardwareBufferFormatProperties2ANDROID*" : "VkAndroidHardwareBufferFormatProperties2ANDROID"), "pNext", indents, reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(object));
            break;
#endif  // VK_USE_PLATFORM_ANDROID_KHR

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD:
            dump_VkPhysicalDeviceGpaFeaturesAMD<Format>(*reinterpret_cast<const VkPhysicalDeviceGpaFeaturesAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceGpaFeaturesAMD*" : "VkPhysicalDeviceGpaFeaturesAMD"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceGpaFeaturesAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD:
            dump_VkPhysicalDeviceGpaPropertiesAMD<Format>(*reinterpret_cast<const VkPhysicalDeviceGpaPropertiesAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceGpaPropertiesAMD*" : "VkPhysicalDeviceGpaPropertiesAMD"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceGpaPropertiesAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD:
            dump_VkPhysicalDeviceGpaProperties2AMD<Format>(*reinterpret_cast<const VkPhysicalDeviceGpaProperties2AMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceGpaProperties2AMD*" : "VkPhysicalDeviceGpaProperties2AMD"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceGpaProperties2AMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD:
            dump_VkGpaSampleBeginInfoAMD<Format>(*reinterpret_cast<const VkGpaSampleBeginInfoAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGpaSampleBeginInfoAMD*" : "VkGpaSampleBeginInfoAMD"), "pNext", indents, reinterpret_cast<const VkGpaSampleBeginInfoAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD:
            dump_VkGpaDeviceClockModeInfoAMD<Format>(*reinterpret_cast<const VkGpaDeviceClockModeInfoAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGpaDeviceClockModeInfoAMD*" : "VkGpaDeviceClockModeInfoAMD"), "pNext", indents, reinterpret_cast<const VkGpaDeviceClockModeInfoAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD:
            dump_VkGpaDeviceGetClockInfoAMD<Format>(*reinterpret_cast<const VkGpaDeviceGetClockInfoAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGpaDeviceGetClockInfoAMD*" : "VkGpaDeviceGetClockInfoAMD"), "pNext", indents, reinterpret_cast<const VkGpaDeviceGetClockInfoAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD:
            dump_VkGpaSessionCreateInfoAMD<Format>(*reinterpret_cast<const VkGpaSessionCreateInfoAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGpaSessionCreateInfoAMD*" : "VkGpaSessionCreateInfoAMD"), "pNext", indents, reinterpret_cast<const VkGpaSessionCreateInfoAMD*>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX:
            dump_VkPhysicalDeviceShaderEnqueueFeaturesAMDX<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderEnqueueFeaturesAMDX*" : "VkPhysicalDeviceShaderEnqueueFeaturesAMDX"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
            dump_VkPhysicalDeviceShaderEnqueuePropertiesAMDX<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderEnqueuePropertiesAMDX*" : "VkPhysicalDeviceShaderEnqueuePropertiesAMDX"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX:
            dump_VkExecutionGraphPipelineScratchSizeAMDX<Format>(*reinterpret_cast<const VkExecutionGraphPipelineScratchSizeAMDX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExecutionGraphPipelineScratchSizeAMDX*" : "VkExecutionGraphPipelineScratchSizeAMDX"), "pNext", indents, reinterpret_cast<const VkExecutionGraphPipelineScratchSizeAMDX*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
            dump_VkExecutionGraphPipelineCreateInfoAMDX<Format>(*reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExecutionGraphPipelineCreateInfoAMDX*" : "VkExecutionGraphPipelineCreateInfoAMDX"), "pNext", indents, reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
            dump_VkPipelineShaderStageNodeCreateInfoAMDX<Format>(*reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineShaderStageNodeCreateInfoAMDX*" : "VkPipelineShaderStageNodeCreateInfoAMDX"), "pNext", indents, reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX*>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS

        case VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT:
            dump_VkTexelBufferDescriptorInfoEXT<Format>(*reinterpret_cast<const VkTexelBufferDescriptorInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTexelBufferDescriptorInfoEXT*" : "VkTexelBufferDescriptorInfoEXT"), "pNext", indents, reinterpret_cast<const VkTexelBufferDescriptorInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT:
            dump_VkImageDescriptorInfoEXT<Format>(*reinterpret_cast<const VkImageDescriptorInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageDescriptorInfoEXT*" : "VkImageDescriptorInfoEXT"), "pNext", indents, reinterpret_cast<const VkImageDescriptorInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM:
            dump_VkTensorViewCreateInfoARM<Format>(*reinterpret_cast<const VkTensorViewCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorViewCreateInfoARM*" : "VkTensorViewCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkTensorViewCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT:
            dump_VkResourceDescriptorInfoEXT<Format>(*reinterpret_cast<const VkResourceDescriptorInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkResourceDescriptorInfoEXT*" : "VkResourceDescriptorInfoEXT"), "pNext", indents, reinterpret_cast<const VkResourceDescriptorInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT:
            dump_VkBindHeapInfoEXT<Format>(*reinterpret_cast<const VkBindHeapInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindHeapInfoEXT*" : "VkBindHeapInfoEXT"), "pNext", indents, reinterpret_cast<const VkBindHeapInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT:
            dump_VkPushDataInfoEXT<Format>(*reinterpret_cast<const VkPushDataInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPushDataInfoEXT*" : "VkPushDataInfoEXT"), "pNext", indents, reinterpret_cast<const VkPushDataInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT:
            dump_VkDescriptorSetAndBindingMappingEXT<Format>(*reinterpret_cast<const VkDescriptorSetAndBindingMappingEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetAndBindingMappingEXT*" : "VkDescriptorSetAndBindingMappingEXT"), "pNext", indents, reinterpret_cast<const VkDescriptorSetAndBindingMappingEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT:
            dump_VkShaderDescriptorSetAndBindingMappingInfoEXT<Format>(*reinterpret_cast<const VkShaderDescriptorSetAndBindingMappingInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderDescriptorSetAndBindingMappingInfoEXT*" : "VkShaderDescriptorSetAndBindingMappingInfoEXT"), "pNext", indents, reinterpret_cast<const VkShaderDescriptorSetAndBindingMappingInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT:
            dump_VkOpaqueCaptureDataCreateInfoEXT<Format>(*reinterpret_cast<const VkOpaqueCaptureDataCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkOpaqueCaptureDataCreateInfoEXT*" : "VkOpaqueCaptureDataCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkOpaqueCaptureDataCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT:
            dump_VkPhysicalDeviceDescriptorHeapFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorHeapFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorHeapFeaturesEXT*" : "VkPhysicalDeviceDescriptorHeapFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorHeapFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT:
            dump_VkPhysicalDeviceDescriptorHeapPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorHeapPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorHeapPropertiesEXT*" : "VkPhysicalDeviceDescriptorHeapPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorHeapPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT:
            dump_VkCommandBufferInheritanceDescriptorHeapInfoEXT<Format>(*reinterpret_cast<const VkCommandBufferInheritanceDescriptorHeapInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceDescriptorHeapInfoEXT*" : "VkCommandBufferInheritanceDescriptorHeapInfoEXT"), "pNext", indents, reinterpret_cast<const VkCommandBufferInheritanceDescriptorHeapInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT:
            dump_VkSamplerCustomBorderColorIndexCreateInfoEXT<Format>(*reinterpret_cast<const VkSamplerCustomBorderColorIndexCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerCustomBorderColorIndexCreateInfoEXT*" : "VkSamplerCustomBorderColorIndexCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkSamplerCustomBorderColorIndexCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
            dump_VkSamplerCustomBorderColorCreateInfoEXT<Format>(*reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerCustomBorderColorCreateInfoEXT*" : "VkSamplerCustomBorderColorCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV:
            dump_VkIndirectCommandsLayoutPushDataTokenNV<Format>(*reinterpret_cast<const VkIndirectCommandsLayoutPushDataTokenNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectCommandsLayoutPushDataTokenNV*" : "VkIndirectCommandsLayoutPushDataTokenNV"), "pNext", indents, reinterpret_cast<const VkIndirectCommandsLayoutPushDataTokenNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT:
            dump_VkSubsampledImageFormatPropertiesEXT<Format>(*reinterpret_cast<const VkSubsampledImageFormatPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubsampledImageFormatPropertiesEXT*" : "VkSubsampledImageFormatPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkSubsampledImageFormatPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM:
            dump_VkPhysicalDeviceDescriptorHeapTensorPropertiesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorHeapTensorPropertiesARM*" : "VkPhysicalDeviceDescriptorHeapTensorPropertiesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
            dump_VkAttachmentSampleCountInfoAMD<Format>(*reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentSampleCountInfoAMD*" : "VkAttachmentSampleCountInfoAMD"), "pNext", indents, reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
            dump_VkSampleLocationsInfoEXT<Format>(*reinterpret_cast<const VkSampleLocationsInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSampleLocationsInfoEXT*" : "VkSampleLocationsInfoEXT"), "pNext", indents, reinterpret_cast<const VkSampleLocationsInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
            dump_VkRenderPassSampleLocationsBeginInfoEXT<Format>(*reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassSampleLocationsBeginInfoEXT*" : "VkRenderPassSampleLocationsBeginInfoEXT"), "pNext", indents, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
            dump_VkPipelineSampleLocationsStateCreateInfoEXT<Format>(*reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineSampleLocationsStateCreateInfoEXT*" : "VkPipelineSampleLocationsStateCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
            dump_VkPhysicalDeviceSampleLocationsPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSampleLocationsPropertiesEXT*" : "VkPhysicalDeviceSampleLocationsPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT:
            dump_VkMultisamplePropertiesEXT<Format>(*reinterpret_cast<const VkMultisamplePropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMultisamplePropertiesEXT*" : "VkMultisamplePropertiesEXT"), "pNext", indents, reinterpret_cast<const VkMultisamplePropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
            dump_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*" : "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
            dump_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*" : "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
            dump_VkPipelineColorBlendAdvancedStateCreateInfoEXT<Format>(*reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineColorBlendAdvancedStateCreateInfoEXT*" : "VkPipelineColorBlendAdvancedStateCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
            dump_VkPipelineCoverageToColorStateCreateInfoNV<Format>(*reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCoverageToColorStateCreateInfoNV*" : "VkPipelineCoverageToColorStateCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
            dump_VkPipelineCoverageModulationStateCreateInfoNV<Format>(*reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCoverageModulationStateCreateInfoNV*" : "VkPipelineCoverageModulationStateCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
            dump_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*" : "VkPhysicalDeviceShaderSMBuiltinsPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
            dump_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*" : "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
            dump_VkDrmFormatModifierPropertiesListEXT<Format>(*reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDrmFormatModifierPropertiesListEXT*" : "VkDrmFormatModifierPropertiesListEXT"), "pNext", indents, reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
            dump_VkPhysicalDeviceImageDrmFormatModifierInfoEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageDrmFormatModifierInfoEXT*" : "VkPhysicalDeviceImageDrmFormatModifierInfoEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
            dump_VkImageDrmFormatModifierListCreateInfoEXT<Format>(*reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageDrmFormatModifierListCreateInfoEXT*" : "VkImageDrmFormatModifierListCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
            dump_VkImageDrmFormatModifierExplicitCreateInfoEXT<Format>(*reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageDrmFormatModifierExplicitCreateInfoEXT*" : "VkImageDrmFormatModifierExplicitCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT:
            dump_VkImageDrmFormatModifierPropertiesEXT<Format>(*reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageDrmFormatModifierPropertiesEXT*" : "VkImageDrmFormatModifierPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
            dump_VkDrmFormatModifierPropertiesList2EXT<Format>(*reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDrmFormatModifierPropertiesList2EXT*" : "VkDrmFormatModifierPropertiesList2EXT"), "pNext", indents, reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT:
            dump_VkValidationCacheCreateInfoEXT<Format>(*reinterpret_cast<const VkValidationCacheCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkValidationCacheCreateInfoEXT*" : "VkValidationCacheCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
            dump_VkShaderModuleValidationCacheCreateInfoEXT<Format>(*reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderModuleValidationCacheCreateInfoEXT*" : "VkShaderModuleValidationCacheCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
            dump_VkPipelineViewportShadingRateImageStateCreateInfoNV<Format>(*reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportShadingRateImageStateCreateInfoNV*" : "VkPipelineViewportShadingRateImageStateCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
            dump_VkPhysicalDeviceShadingRateImageFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShadingRateImageFeaturesNV*" : "VkPhysicalDeviceShadingRateImageFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
            dump_VkPhysicalDeviceShadingRateImagePropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShadingRateImagePropertiesNV*" : "VkPhysicalDeviceShadingRateImagePropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
            dump_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV<Format>(*reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*" : "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV:
            dump_VkRayTracingShaderGroupCreateInfoNV<Format>(*reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingShaderGroupCreateInfoNV*" : "VkRayTracingShaderGroupCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
            dump_VkRayTracingPipelineCreateInfoNV<Format>(*reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingPipelineCreateInfoNV*" : "VkRayTracingPipelineCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV:
            dump_VkGeometryTrianglesNV<Format>(*reinterpret_cast<const VkGeometryTrianglesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGeometryTrianglesNV*" : "VkGeometryTrianglesNV"), "pNext", indents, reinterpret_cast<const VkGeometryTrianglesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV:
            dump_VkGeometryAABBNV<Format>(*reinterpret_cast<const VkGeometryAABBNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGeometryAABBNV*" : "VkGeometryAABBNV"), "pNext", indents, reinterpret_cast<const VkGeometryAABBNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_GEOMETRY_NV:
            dump_VkGeometryNV<Format>(*reinterpret_cast<const VkGeometryNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGeometryNV*" : "VkGeometryNV"), "pNext", indents, reinterpret_cast<const VkGeometryNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV:
            dump_VkAccelerationStructureInfoNV<Format>(*reinterpret_cast<const VkAccelerationStructureInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureInfoNV*" : "VkAccelerationStructureInfoNV"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
            dump_VkAccelerationStructureCreateInfoNV<Format>(*reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureCreateInfoNV*" : "VkAccelerationStructureCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV:
            dump_VkBindAccelerationStructureMemoryInfoNV<Format>(*reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindAccelerationStructureMemoryInfoNV*" : "VkBindAccelerationStructureMemoryInfoNV"), "pNext", indents, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
            dump_VkWriteDescriptorSetAccelerationStructureNV<Format>(*reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSetAccelerationStructureNV*" : "VkWriteDescriptorSetAccelerationStructureNV"), "pNext", indents, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV:
            dump_VkAccelerationStructureMemoryRequirementsInfoNV<Format>(*reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureMemoryRequirementsInfoNV*" : "VkAccelerationStructureMemoryRequirementsInfoNV"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
            dump_VkPhysicalDeviceRayTracingPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingPropertiesNV*" : "VkPhysicalDeviceRayTracingPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
            dump_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*" : "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
            dump_VkPipelineRepresentativeFragmentTestStateCreateInfoNV<Format>(*reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRepresentativeFragmentTestStateCreateInfoNV*" : "VkPipelineRepresentativeFragmentTestStateCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
            dump_VkPhysicalDeviceImageViewImageFormatInfoEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageViewImageFormatInfoEXT*" : "VkPhysicalDeviceImageViewImageFormatInfoEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
            dump_VkFilterCubicImageViewImageFormatPropertiesEXT<Format>(*reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFilterCubicImageViewImageFormatPropertiesEXT*" : "VkFilterCubicImageViewImageFormatPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM:
            dump_VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*" : "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM:
            dump_VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM*" : "VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
            dump_VkImportMemoryHostPointerInfoEXT<Format>(*reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryHostPointerInfoEXT*" : "VkImportMemoryHostPointerInfoEXT"), "pNext", indents, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT:
            dump_VkMemoryHostPointerPropertiesEXT<Format>(*reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryHostPointerPropertiesEXT*" : "VkMemoryHostPointerPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
            dump_VkPhysicalDeviceExternalMemoryHostPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalMemoryHostPropertiesEXT*" : "VkPhysicalDeviceExternalMemoryHostPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
            dump_VkPipelineCompilerControlCreateInfoAMD<Format>(*reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCompilerControlCreateInfoAMD*" : "VkPipelineCompilerControlCreateInfoAMD"), "pNext", indents, reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
            dump_VkPhysicalDeviceShaderCorePropertiesAMD<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderCorePropertiesAMD*" : "VkPhysicalDeviceShaderCorePropertiesAMD"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
            dump_VkDeviceMemoryOverallocationCreateInfoAMD<Format>(*reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceMemoryOverallocationCreateInfoAMD*" : "VkDeviceMemoryOverallocationCreateInfoAMD"), "pNext", indents, reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
            dump_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*" : "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_GGP)

        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
            dump_VkPresentFrameTokenGGP<Format>(*reinterpret_cast<const VkPresentFrameTokenGGP*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentFrameTokenGGP*" : "VkPresentFrameTokenGGP"), "pNext", indents, reinterpret_cast<const VkPresentFrameTokenGGP*>(object));
            break;
#endif  // VK_USE_PLATFORM_GGP

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
            dump_VkPhysicalDeviceMeshShaderFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMeshShaderFeaturesNV*" : "VkPhysicalDeviceMeshShaderFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
            dump_VkPhysicalDeviceMeshShaderPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMeshShaderPropertiesNV*" : "VkPhysicalDeviceMeshShaderPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
            dump_VkPhysicalDeviceShaderImageFootprintFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderImageFootprintFeaturesNV*" : "VkPhysicalDeviceShaderImageFootprintFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
            dump_VkPipelineViewportExclusiveScissorStateCreateInfoNV<Format>(*reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportExclusiveScissorStateCreateInfoNV*" : "VkPipelineViewportExclusiveScissorStateCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
            dump_VkPhysicalDeviceExclusiveScissorFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExclusiveScissorFeaturesNV*" : "VkPhysicalDeviceExclusiveScissorFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
            dump_VkQueueFamilyCheckpointPropertiesNV<Format>(*reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyCheckpointPropertiesNV*" : "VkQueueFamilyCheckpointPropertiesNV"), "pNext", indents, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV:
            dump_VkCheckpointDataNV<Format>(*reinterpret_cast<const VkCheckpointDataNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCheckpointDataNV*" : "VkCheckpointDataNV"), "pNext", indents, reinterpret_cast<const VkCheckpointDataNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
            dump_VkQueueFamilyCheckpointProperties2NV<Format>(*reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyCheckpointProperties2NV*" : "VkQueueFamilyCheckpointProperties2NV"), "pNext", indents, reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(object));
            break;

        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV:
            dump_VkCheckpointData2NV<Format>(*reinterpret_cast<const VkCheckpointData2NV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCheckpointData2NV*" : "VkCheckpointData2NV"), "pNext", indents, reinterpret_cast<const VkCheckpointData2NV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT:
            dump_VkPhysicalDevicePresentTimingFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDevicePresentTimingFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentTimingFeaturesEXT*" : "VkPhysicalDevicePresentTimingFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePresentTimingFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT:
            dump_VkPresentTimingSurfaceCapabilitiesEXT<Format>(*reinterpret_cast<const VkPresentTimingSurfaceCapabilitiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentTimingSurfaceCapabilitiesEXT*" : "VkPresentTimingSurfaceCapabilitiesEXT"), "pNext", indents, reinterpret_cast<const VkPresentTimingSurfaceCapabilitiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT:
            dump_VkSwapchainCalibratedTimestampInfoEXT<Format>(*reinterpret_cast<const VkSwapchainCalibratedTimestampInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainCalibratedTimestampInfoEXT*" : "VkSwapchainCalibratedTimestampInfoEXT"), "pNext", indents, reinterpret_cast<const VkSwapchainCalibratedTimestampInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT:
            dump_VkSwapchainTimingPropertiesEXT<Format>(*reinterpret_cast<const VkSwapchainTimingPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainTimingPropertiesEXT*" : "VkSwapchainTimingPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkSwapchainTimingPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT:
            dump_VkSwapchainTimeDomainPropertiesEXT<Format>(*reinterpret_cast<const VkSwapchainTimeDomainPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainTimeDomainPropertiesEXT*" : "VkSwapchainTimeDomainPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkSwapchainTimeDomainPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT:
            dump_VkPastPresentationTimingInfoEXT<Format>(*reinterpret_cast<const VkPastPresentationTimingInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPastPresentationTimingInfoEXT*" : "VkPastPresentationTimingInfoEXT"), "pNext", indents, reinterpret_cast<const VkPastPresentationTimingInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT:
            dump_VkPastPresentationTimingEXT<Format>(*reinterpret_cast<const VkPastPresentationTimingEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPastPresentationTimingEXT*" : "VkPastPresentationTimingEXT"), "pNext", indents, reinterpret_cast<const VkPastPresentationTimingEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT:
            dump_VkPastPresentationTimingPropertiesEXT<Format>(*reinterpret_cast<const VkPastPresentationTimingPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPastPresentationTimingPropertiesEXT*" : "VkPastPresentationTimingPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPastPresentationTimingPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT:
            dump_VkPresentTimingInfoEXT<Format>(*reinterpret_cast<const VkPresentTimingInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentTimingInfoEXT*" : "VkPresentTimingInfoEXT"), "pNext", indents, reinterpret_cast<const VkPresentTimingInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT:
            dump_VkPresentTimingsInfoEXT<Format>(*reinterpret_cast<const VkPresentTimingsInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentTimingsInfoEXT*" : "VkPresentTimingsInfoEXT"), "pNext", indents, reinterpret_cast<const VkPresentTimingsInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
            dump_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*" : "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(object));
            break;

        case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL:
            dump_VkInitializePerformanceApiInfoINTEL<Format>(*reinterpret_cast<const VkInitializePerformanceApiInfoINTEL*>(object), settings, (Format == ApiDumpFormat::Json ? "VkInitializePerformanceApiInfoINTEL*" : "VkInitializePerformanceApiInfoINTEL"), "pNext", indents, reinterpret_cast<const VkInitializePerformanceApiInfoINTEL*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
            dump_VkQueryPoolPerformanceQueryCreateInfoINTEL<Format>(*reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueryPoolPerformanceQueryCreateInfoINTEL*" : "VkQueryPoolPerformanceQueryCreateInfoINTEL"), "pNext", indents, reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(object));
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL:
            dump_VkPerformanceMarkerInfoINTEL<Format>(*reinterpret_cast<const VkPerformanceMarkerInfoINTEL*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceMarkerInfoINTEL*" : "VkPerformanceMarkerInfoINTEL"), "pNext", indents, reinterpret_cast<const VkPerformanceMarkerInfoINTEL*>(object));
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL:
            dump_VkPerformanceStreamMarkerInfoINTEL<Format>(*reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceStreamMarkerInfoINTEL*" : "VkPerformanceStreamMarkerInfoINTEL"), "pNext", indents, reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL*>(object));
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL:
            dump_VkPerformanceOverrideInfoINTEL<Format>(*reinterpret_cast<const VkPerformanceOverrideInfoINTEL*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceOverrideInfoINTEL*" : "VkPerformanceOverrideInfoINTEL"), "pNext", indents, reinterpret_cast<const VkPerformanceOverrideInfoINTEL*>(object));
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL:
            dump_VkPerformanceConfigurationAcquireInfoINTEL<Format>(*reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceConfigurationAcquireInfoINTEL*" : "VkPerformanceConfigurationAcquireInfoINTEL"), "pNext", indents, reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
            dump_VkPhysicalDevicePCIBusInfoPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePCIBusInfoPropertiesEXT*" : "VkPhysicalDevicePCIBusInfoPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
            dump_VkDisplayNativeHdrSurfaceCapabilitiesAMD<Format>(*reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayNativeHdrSurfaceCapabilitiesAMD*" : "VkDisplayNativeHdrSurfaceCapabilitiesAMD"), "pNext", indents, reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
            dump_VkSwapchainDisplayNativeHdrCreateInfoAMD<Format>(*reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainDisplayNativeHdrCreateInfoAMD*" : "VkSwapchainDisplayNativeHdrCreateInfoAMD"), "pNext", indents, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(object));
            break;
#if defined(VK_USE_PLATFORM_FUCHSIA)

        case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA:
            dump_VkImagePipeSurfaceCreateInfoFUCHSIA<Format>(*reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImagePipeSurfaceCreateInfoFUCHSIA*" : "VkImagePipeSurfaceCreateInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>(object));
            break;
#endif  // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_METAL_EXT)

        case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT:
            dump_VkMetalSurfaceCreateInfoEXT<Format>(*reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMetalSurfaceCreateInfoEXT*" : "VkMetalSurfaceCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>(object));
            break;
#endif  // VK_USE_PLATFORM_METAL_EXT

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
            dump_VkPhysicalDeviceFragmentDensityMapFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapFeaturesEXT*" : "VkPhysicalDeviceFragmentDensityMapFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
            dump_VkPhysicalDeviceFragmentDensityMapPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapPropertiesEXT*" : "VkPhysicalDeviceFragmentDensityMapPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
            dump_VkRenderPassFragmentDensityMapCreateInfoEXT<Format>(*reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassFragmentDensityMapCreateInfoEXT*" : "VkRenderPassFragmentDensityMapCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
            dump_VkRenderingFragmentDensityMapAttachmentInfoEXT<Format>(*reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingFragmentDensityMapAttachmentInfoEXT*" : "VkRenderingFragmentDensityMapAttachmentInfoEXT"), "pNext", indents, reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
            dump_VkPhysicalDeviceShaderCoreProperties2AMD<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderCoreProperties2AMD*" : "VkPhysicalDeviceShaderCoreProperties2AMD"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
            dump_VkPhysicalDeviceCoherentMemoryFeaturesAMD<Format>(*reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCoherentMemoryFeaturesAMD*" : "VkPhysicalDeviceCoherentMemoryFeaturesAMD"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*" : "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
            dump_VkPhysicalDeviceMemoryBudgetPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMemoryBudgetPropertiesEXT*" : "VkPhysicalDeviceMemoryBudgetPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
            dump_VkPhysicalDeviceMemoryPriorityFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMemoryPriorityFeaturesEXT*" : "VkPhysicalDeviceMemoryPriorityFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
            dump_VkMemoryPriorityAllocateInfoEXT<Format>(*reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryPriorityAllocateInfoEXT*" : "VkMemoryPriorityAllocateInfoEXT"), "pNext", indents, reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
            dump_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*" : "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
            dump_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*" : "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
            dump_VkBufferDeviceAddressCreateInfoEXT<Format>(*reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferDeviceAddressCreateInfoEXT*" : "VkBufferDeviceAddressCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
            dump_VkValidationFeaturesEXT<Format>(*reinterpret_cast<const VkValidationFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkValidationFeaturesEXT*" : "VkValidationFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkValidationFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV:
            dump_VkCooperativeMatrixPropertiesNV<Format>(*reinterpret_cast<const VkCooperativeMatrixPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCooperativeMatrixPropertiesNV*" : "VkCooperativeMatrixPropertiesNV"), "pNext", indents, reinterpret_cast<const VkCooperativeMatrixPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
            dump_VkPhysicalDeviceCooperativeMatrixFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixFeaturesNV*" : "VkPhysicalDeviceCooperativeMatrixFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
            dump_VkPhysicalDeviceCooperativeMatrixPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixPropertiesNV*" : "VkPhysicalDeviceCooperativeMatrixPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
            dump_VkPhysicalDeviceCoverageReductionModeFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCoverageReductionModeFeaturesNV*" : "VkPhysicalDeviceCoverageReductionModeFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
            dump_VkPipelineCoverageReductionStateCreateInfoNV<Format>(*reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCoverageReductionStateCreateInfoNV*" : "VkPipelineCoverageReductionStateCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV:
            dump_VkFramebufferMixedSamplesCombinationNV<Format>(*reinterpret_cast<const VkFramebufferMixedSamplesCombinationNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFramebufferMixedSamplesCombinationNV*" : "VkFramebufferMixedSamplesCombinationNV"), "pNext", indents, reinterpret_cast<const VkFramebufferMixedSamplesCombinationNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
            dump_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*" : "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
            dump_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*" : "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
            dump_VkPhysicalDeviceProvokingVertexFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceProvokingVertexFeaturesEXT*" : "VkPhysicalDeviceProvokingVertexFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
            dump_VkPhysicalDeviceProvokingVertexPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceProvokingVertexPropertiesEXT*" : "VkPhysicalDeviceProvokingVertexPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
            dump_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT<Format>(*reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*" : "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)

        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
            dump_VkSurfaceFullScreenExclusiveInfoEXT<Format>(*reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceFullScreenExclusiveInfoEXT*" : "VkSurfaceFullScreenExclusiveInfoEXT"), "pNext", indents, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
            dump_VkSurfaceCapabilitiesFullScreenExclusiveEXT<Format>(*reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilitiesFullScreenExclusiveEXT*" : "VkSurfaceCapabilitiesFullScreenExclusiveEXT"), "pNext", indents, reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
            dump_VkSurfaceFullScreenExclusiveWin32InfoEXT<Format>(*reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceFullScreenExclusiveWin32InfoEXT*" : "VkSurfaceFullScreenExclusiveWin32InfoEXT"), "pNext", indents, reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(object));
            break;
#endif  // VK_USE_PLATFORM_WIN32_KHR

        case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT:
            dump_VkHeadlessSurfaceCreateInfoEXT<Format>(*reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkHeadlessSurfaceCreateInfoEXT*" : "VkHeadlessSurfaceCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*" : "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
            dump_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*" : "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
            dump_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*" : "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
            dump_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT*" : "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
            dump_VkMemoryMapPlacedInfoEXT<Format>(*reinterpret_cast<const VkMemoryMapPlacedInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryMapPlacedInfoEXT*" : "VkMemoryMapPlacedInfoEXT"), "pNext", indents, reinterpret_cast<const VkMemoryMapPlacedInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*" : "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
            dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*" : "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
            dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*" : "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV:
            dump_VkGraphicsShaderGroupCreateInfoNV<Format>(*reinterpret_cast<const VkGraphicsShaderGroupCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGraphicsShaderGroupCreateInfoNV*" : "VkGraphicsShaderGroupCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkGraphicsShaderGroupCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
            dump_VkGraphicsPipelineShaderGroupsCreateInfoNV<Format>(*reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGraphicsPipelineShaderGroupsCreateInfoNV*" : "VkGraphicsPipelineShaderGroupsCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV:
            dump_VkIndirectCommandsLayoutTokenNV<Format>(*reinterpret_cast<const VkIndirectCommandsLayoutTokenNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectCommandsLayoutTokenNV*" : "VkIndirectCommandsLayoutTokenNV"), "pNext", indents, reinterpret_cast<const VkIndirectCommandsLayoutTokenNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV:
            dump_VkIndirectCommandsLayoutCreateInfoNV<Format>(*reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectCommandsLayoutCreateInfoNV*" : "VkIndirectCommandsLayoutCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV:
            dump_VkGeneratedCommandsInfoNV<Format>(*reinterpret_cast<const VkGeneratedCommandsInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsInfoNV*" : "VkGeneratedCommandsInfoNV"), "pNext", indents, reinterpret_cast<const VkGeneratedCommandsInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV:
            dump_VkGeneratedCommandsMemoryRequirementsInfoNV<Format>(*reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsMemoryRequirementsInfoNV*" : "VkGeneratedCommandsMemoryRequirementsInfoNV"), "pNext", indents, reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
            dump_VkPhysicalDeviceInheritedViewportScissorFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceInheritedViewportScissorFeaturesNV*" : "VkPhysicalDeviceInheritedViewportScissorFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
            dump_VkCommandBufferInheritanceViewportScissorInfoNV<Format>(*reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceViewportScissorInfoNV*" : "VkCommandBufferInheritanceViewportScissorInfoNV"), "pNext", indents, reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
            dump_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*" : "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
            dump_VkRenderPassTransformBeginInfoQCOM<Format>(*reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassTransformBeginInfoQCOM*" : "VkRenderPassTransformBeginInfoQCOM"), "pNext", indents, reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
            dump_VkCommandBufferInheritanceRenderPassTransformInfoQCOM<Format>(*reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceRenderPassTransformInfoQCOM*" : "VkCommandBufferInheritanceRenderPassTransformInfoQCOM"), "pNext", indents, reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
            dump_VkPhysicalDeviceDepthBiasControlFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthBiasControlFeaturesEXT*" : "VkPhysicalDeviceDepthBiasControlFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT:
            dump_VkDepthBiasInfoEXT<Format>(*reinterpret_cast<const VkDepthBiasInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDepthBiasInfoEXT*" : "VkDepthBiasInfoEXT"), "pNext", indents, reinterpret_cast<const VkDepthBiasInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
            dump_VkDepthBiasRepresentationInfoEXT<Format>(*reinterpret_cast<const VkDepthBiasRepresentationInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDepthBiasRepresentationInfoEXT*" : "VkDepthBiasRepresentationInfoEXT"), "pNext", indents, reinterpret_cast<const VkDepthBiasRepresentationInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
            dump_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*" : "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT:
            dump_VkDeviceMemoryReportCallbackDataEXT<Format>(*reinterpret_cast<const VkDeviceMemoryReportCallbackDataEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceMemoryReportCallbackDataEXT*" : "VkDeviceMemoryReportCallbackDataEXT"), "pNext", indents, reinterpret_cast<const VkDeviceMemoryReportCallbackDataEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
            dump_VkDeviceDeviceMemoryReportCreateInfoEXT<Format>(*reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceDeviceMemoryReportCreateInfoEXT*" : "VkDeviceDeviceMemoryReportCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
            dump_VkPhysicalDeviceCustomBorderColorPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCustomBorderColorPropertiesEXT*" : "VkPhysicalDeviceCustomBorderColorPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
            dump_VkPhysicalDeviceCustomBorderColorFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCustomBorderColorFeaturesEXT*" : "VkPhysicalDeviceCustomBorderColorFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT:
            dump_VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*" : "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
            dump_VkPhysicalDevicePresentBarrierFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentBarrierFeaturesNV*" : "VkPhysicalDevicePresentBarrierFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
            dump_VkSurfaceCapabilitiesPresentBarrierNV<Format>(*reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilitiesPresentBarrierNV*" : "VkSurfaceCapabilitiesPresentBarrierNV"), "pNext", indents, reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
            dump_VkSwapchainPresentBarrierCreateInfoNV<Format>(*reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainPresentBarrierCreateInfoNV*" : "VkSwapchainPresentBarrierCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
            dump_VkPhysicalDeviceDiagnosticsConfigFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDiagnosticsConfigFeaturesNV*" : "VkPhysicalDeviceDiagnosticsConfigFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
            dump_VkDeviceDiagnosticsConfigCreateInfoNV<Format>(*reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceDiagnosticsConfigCreateInfoNV*" : "VkDeviceDiagnosticsConfigCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM:
            dump_VkPerfHintInfoQCOM<Format>(*reinterpret_cast<const VkPerfHintInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerfHintInfoQCOM*" : "VkPerfHintInfoQCOM"), "pNext", indents, reinterpret_cast<const VkPerfHintInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM:
            dump_VkPhysicalDeviceQueuePerfHintFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceQueuePerfHintFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceQueuePerfHintFeaturesQCOM*" : "VkPhysicalDeviceQueuePerfHintFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceQueuePerfHintFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM:
            dump_VkPhysicalDeviceQueuePerfHintPropertiesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceQueuePerfHintPropertiesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceQueuePerfHintPropertiesQCOM*" : "VkPhysicalDeviceQueuePerfHintPropertiesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceQueuePerfHintPropertiesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM:
            dump_VkPhysicalDeviceImageProcessing3FeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceImageProcessing3FeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageProcessing3FeaturesQCOM*" : "VkPhysicalDeviceImageProcessing3FeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageProcessing3FeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM:
            dump_VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM*" : "VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM:
            dump_VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM*" : "VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderSplitBarrierFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSplitBarrierFeaturesEXT*" : "VkPhysicalDeviceShaderSplitBarrierFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT:
            dump_VkPhysicalDeviceShaderSplitBarrierPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSplitBarrierPropertiesEXT*" : "VkPhysicalDeviceShaderSplitBarrierPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT*>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)

        case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV:
            dump_VkCudaModuleCreateInfoNV<Format>(*reinterpret_cast<const VkCudaModuleCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCudaModuleCreateInfoNV*" : "VkCudaModuleCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkCudaModuleCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV:
            dump_VkCudaFunctionCreateInfoNV<Format>(*reinterpret_cast<const VkCudaFunctionCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCudaFunctionCreateInfoNV*" : "VkCudaFunctionCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkCudaFunctionCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV:
            dump_VkCudaLaunchInfoNV<Format>(*reinterpret_cast<const VkCudaLaunchInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCudaLaunchInfoNV*" : "VkCudaLaunchInfoNV"), "pNext", indents, reinterpret_cast<const VkCudaLaunchInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
            dump_VkPhysicalDeviceCudaKernelLaunchFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCudaKernelLaunchFeaturesNV*" : "VkPhysicalDeviceCudaKernelLaunchFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
            dump_VkPhysicalDeviceCudaKernelLaunchPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCudaKernelLaunchPropertiesNV*" : "VkPhysicalDeviceCudaKernelLaunchPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV*>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
            dump_VkPhysicalDeviceTileShadingFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTileShadingFeaturesQCOM*" : "VkPhysicalDeviceTileShadingFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
            dump_VkPhysicalDeviceTileShadingPropertiesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceTileShadingPropertiesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTileShadingPropertiesQCOM*" : "VkPhysicalDeviceTileShadingPropertiesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTileShadingPropertiesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
            dump_VkRenderPassTileShadingCreateInfoQCOM<Format>(*reinterpret_cast<const VkRenderPassTileShadingCreateInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassTileShadingCreateInfoQCOM*" : "VkRenderPassTileShadingCreateInfoQCOM"), "pNext", indents, reinterpret_cast<const VkRenderPassTileShadingCreateInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM:
            dump_VkPerTileBeginInfoQCOM<Format>(*reinterpret_cast<const VkPerTileBeginInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerTileBeginInfoQCOM*" : "VkPerTileBeginInfoQCOM"), "pNext", indents, reinterpret_cast<const VkPerTileBeginInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM:
            dump_VkPerTileEndInfoQCOM<Format>(*reinterpret_cast<const VkPerTileEndInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerTileEndInfoQCOM*" : "VkPerTileEndInfoQCOM"), "pNext", indents, reinterpret_cast<const VkPerTileEndInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM:
            dump_VkDispatchTileInfoQCOM<Format>(*reinterpret_cast<const VkDispatchTileInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDispatchTileInfoQCOM*" : "VkDispatchTileInfoQCOM"), "pNext", indents, reinterpret_cast<const VkDispatchTileInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
            dump_VkQueryLowLatencySupportNV<Format>(*reinterpret_cast<const VkQueryLowLatencySupportNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueryLowLatencySupportNV*" : "VkQueryLowLatencySupportNV"), "pNext", indents, reinterpret_cast<const VkQueryLowLatencySupportNV*>(object));
            break;
#if defined(VK_USE_PLATFORM_METAL_EXT)

        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
            dump_VkExportMetalObjectCreateInfoEXT<Format>(*reinterpret_cast<const VkExportMetalObjectCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalObjectCreateInfoEXT*" : "VkExportMetalObjectCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkExportMetalObjectCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT:
            dump_VkExportMetalObjectsInfoEXT<Format>(*reinterpret_cast<const VkExportMetalObjectsInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalObjectsInfoEXT*" : "VkExportMetalObjectsInfoEXT"), "pNext", indents, reinterpret_cast<const VkExportMetalObjectsInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
            dump_VkExportMetalDeviceInfoEXT<Format>(*reinterpret_cast<const VkExportMetalDeviceInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalDeviceInfoEXT*" : "VkExportMetalDeviceInfoEXT"), "pNext", indents, reinterpret_cast<const VkExportMetalDeviceInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
            dump_VkExportMetalCommandQueueInfoEXT<Format>(*reinterpret_cast<const VkExportMetalCommandQueueInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalCommandQueueInfoEXT*" : "VkExportMetalCommandQueueInfoEXT"), "pNext", indents, reinterpret_cast<const VkExportMetalCommandQueueInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
            dump_VkExportMetalBufferInfoEXT<Format>(*reinterpret_cast<const VkExportMetalBufferInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalBufferInfoEXT*" : "VkExportMetalBufferInfoEXT"), "pNext", indents, reinterpret_cast<const VkExportMetalBufferInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
            dump_VkImportMetalBufferInfoEXT<Format>(*reinterpret_cast<const VkImportMetalBufferInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMetalBufferInfoEXT*" : "VkImportMetalBufferInfoEXT"), "pNext", indents, reinterpret_cast<const VkImportMetalBufferInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
            dump_VkExportMetalTextureInfoEXT<Format>(*reinterpret_cast<const VkExportMetalTextureInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalTextureInfoEXT*" : "VkExportMetalTextureInfoEXT"), "pNext", indents, reinterpret_cast<const VkExportMetalTextureInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
            dump_VkImportMetalTextureInfoEXT<Format>(*reinterpret_cast<const VkImportMetalTextureInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMetalTextureInfoEXT*" : "VkImportMetalTextureInfoEXT"), "pNext", indents, reinterpret_cast<const VkImportMetalTextureInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
            dump_VkExportMetalIOSurfaceInfoEXT<Format>(*reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalIOSurfaceInfoEXT*" : "VkExportMetalIOSurfaceInfoEXT"), "pNext", indents, reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
            dump_VkImportMetalIOSurfaceInfoEXT<Format>(*reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMetalIOSurfaceInfoEXT*" : "VkImportMetalIOSurfaceInfoEXT"), "pNext", indents, reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
            dump_VkExportMetalSharedEventInfoEXT<Format>(*reinterpret_cast<const VkExportMetalSharedEventInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalSharedEventInfoEXT*" : "VkExportMetalSharedEventInfoEXT"), "pNext", indents, reinterpret_cast<const VkExportMetalSharedEventInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
            dump_VkImportMetalSharedEventInfoEXT<Format>(*reinterpret_cast<const VkImportMetalSharedEventInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMetalSharedEventInfoEXT*" : "VkImportMetalSharedEventInfoEXT"), "pNext", indents, reinterpret_cast<const VkImportMetalSharedEventInfoEXT*>(object));
            break;
#endif  // VK_USE_PLATFORM_METAL_EXT

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
            dump_VkPhysicalDeviceDescriptorBufferPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferPropertiesEXT*" : "VkPhysicalDeviceDescriptorBufferPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
            dump_VkPhysicalDeviceDescriptorBufferFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferFeaturesEXT*" : "VkPhysicalDeviceDescriptorBufferFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT:
            dump_VkDescriptorAddressInfoEXT<Format>(*reinterpret_cast<const VkDescriptorAddressInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorAddressInfoEXT*" : "VkDescriptorAddressInfoEXT"), "pNext", indents, reinterpret_cast<const VkDescriptorAddressInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT:
            dump_VkDescriptorBufferBindingInfoEXT<Format>(*reinterpret_cast<const VkDescriptorBufferBindingInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorBufferBindingInfoEXT*" : "VkDescriptorBufferBindingInfoEXT"), "pNext", indents, reinterpret_cast<const VkDescriptorBufferBindingInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
            dump_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT<Format>(*reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*" : "VkDescriptorBufferBindingPushDescriptorBufferHandleEXT"), "pNext", indents, reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT:
            dump_VkDescriptorGetInfoEXT<Format>(*reinterpret_cast<const VkDescriptorGetInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorGetInfoEXT*" : "VkDescriptorGetInfoEXT"), "pNext", indents, reinterpret_cast<const VkDescriptorGetInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_VkBufferCaptureDescriptorDataInfoEXT<Format>(*reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCaptureDescriptorDataInfoEXT*" : "VkBufferCaptureDescriptorDataInfoEXT"), "pNext", indents, reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_VkImageCaptureDescriptorDataInfoEXT<Format>(*reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageCaptureDescriptorDataInfoEXT*" : "VkImageCaptureDescriptorDataInfoEXT"), "pNext", indents, reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_VkImageViewCaptureDescriptorDataInfoEXT<Format>(*reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewCaptureDescriptorDataInfoEXT*" : "VkImageViewCaptureDescriptorDataInfoEXT"), "pNext", indents, reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_VkSamplerCaptureDescriptorDataInfoEXT<Format>(*reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerCaptureDescriptorDataInfoEXT*" : "VkSamplerCaptureDescriptorDataInfoEXT"), "pNext", indents, reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
            dump_VkOpaqueCaptureDescriptorDataCreateInfoEXT<Format>(*reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkOpaqueCaptureDescriptorDataCreateInfoEXT*" : "VkOpaqueCaptureDescriptorDataCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
            dump_VkAccelerationStructureCaptureDescriptorDataInfoEXT<Format>(*reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureCaptureDescriptorDataInfoEXT*" : "VkAccelerationStructureCaptureDescriptorDataInfoEXT"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
            dump_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*" : "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
            dump_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*" : "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
            dump_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*" : "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
            dump_VkGraphicsPipelineLibraryCreateInfoEXT<Format>(*reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGraphicsPipelineLibraryCreateInfoEXT*" : "VkGraphicsPipelineLibraryCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
            dump_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*" : "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
            dump_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*" : "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
            dump_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*" : "VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
            dump_VkPipelineFragmentShadingRateEnumStateCreateInfoNV<Format>(*reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineFragmentShadingRateEnumStateCreateInfoNV*" : "VkPipelineFragmentShadingRateEnumStateCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
            dump_VkAccelerationStructureGeometryMotionTrianglesDataNV<Format>(*reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryMotionTrianglesDataNV*" : "VkAccelerationStructureGeometryMotionTrianglesDataNV"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
            dump_VkAccelerationStructureMotionInfoNV<Format>(*reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureMotionInfoNV*" : "VkAccelerationStructureMotionInfoNV"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
            dump_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*" : "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
            dump_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*" : "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
            dump_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*" : "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
            dump_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*" : "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
            dump_VkCopyCommandTransformInfoQCOM<Format>(*reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyCommandTransformInfoQCOM*" : "VkCopyCommandTransformInfoQCOM"), "pNext", indents, reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
            dump_VkPhysicalDeviceImageCompressionControlFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageCompressionControlFeaturesEXT*" : "VkPhysicalDeviceImageCompressionControlFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
            dump_VkImageCompressionControlEXT<Format>(*reinterpret_cast<const VkImageCompressionControlEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageCompressionControlEXT*" : "VkImageCompressionControlEXT"), "pNext", indents, reinterpret_cast<const VkImageCompressionControlEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
            dump_VkImageCompressionPropertiesEXT<Format>(*reinterpret_cast<const VkImageCompressionPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageCompressionPropertiesEXT*" : "VkImageCompressionPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkImageCompressionPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
            dump_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*" : "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
            dump_VkPhysicalDevice4444FormatsFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevice4444FormatsFeaturesEXT*" : "VkPhysicalDevice4444FormatsFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
            dump_VkPhysicalDeviceFaultFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFaultFeaturesEXT*" : "VkPhysicalDeviceFaultFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT:
            dump_VkDeviceFaultCountsEXT<Format>(*reinterpret_cast<const VkDeviceFaultCountsEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceFaultCountsEXT*" : "VkDeviceFaultCountsEXT"), "pNext", indents, reinterpret_cast<const VkDeviceFaultCountsEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT:
            dump_VkDeviceFaultInfoEXT<Format>(*reinterpret_cast<const VkDeviceFaultInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceFaultInfoEXT*" : "VkDeviceFaultInfoEXT"), "pNext", indents, reinterpret_cast<const VkDeviceFaultInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
            dump_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*" : "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
            dump_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*" : "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)

        case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT:
            dump_VkDirectFBSurfaceCreateInfoEXT<Format>(*reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDirectFBSurfaceCreateInfoEXT*" : "VkDirectFBSurfaceCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT*>(object));
            break;
#endif  // VK_USE_PLATFORM_DIRECTFB_EXT

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
            dump_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*" : "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
            dump_VkMutableDescriptorTypeCreateInfoEXT<Format>(*reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMutableDescriptorTypeCreateInfoEXT*" : "VkMutableDescriptorTypeCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
            dump_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*" : "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT:
            dump_VkVertexInputBindingDescription2EXT<Format>(*reinterpret_cast<const VkVertexInputBindingDescription2EXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVertexInputBindingDescription2EXT*" : "VkVertexInputBindingDescription2EXT"), "pNext", indents, reinterpret_cast<const VkVertexInputBindingDescription2EXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT:
            dump_VkVertexInputAttributeDescription2EXT<Format>(*reinterpret_cast<const VkVertexInputAttributeDescription2EXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVertexInputAttributeDescription2EXT*" : "VkVertexInputAttributeDescription2EXT"), "pNext", indents, reinterpret_cast<const VkVertexInputAttributeDescription2EXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
            dump_VkPhysicalDeviceDrmPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDrmPropertiesEXT*" : "VkPhysicalDeviceDrmPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
            dump_VkPhysicalDeviceAddressBindingReportFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAddressBindingReportFeaturesEXT*" : "VkPhysicalDeviceAddressBindingReportFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
            dump_VkDeviceAddressBindingCallbackDataEXT<Format>(*reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceAddressBindingCallbackDataEXT*" : "VkDeviceAddressBindingCallbackDataEXT"), "pNext", indents, reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
            dump_VkPhysicalDeviceDepthClipControlFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthClipControlFeaturesEXT*" : "VkPhysicalDeviceDepthClipControlFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
            dump_VkPipelineViewportDepthClipControlCreateInfoEXT<Format>(*reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportDepthClipControlCreateInfoEXT*" : "VkPipelineViewportDepthClipControlCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
            dump_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*" : "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_FUCHSIA)

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_VkImportMemoryZirconHandleInfoFUCHSIA<Format>(*reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryZirconHandleInfoFUCHSIA*" : "VkImportMemoryZirconHandleInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA:
            dump_VkMemoryZirconHandlePropertiesFUCHSIA<Format>(*reinterpret_cast<const VkMemoryZirconHandlePropertiesFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryZirconHandlePropertiesFUCHSIA*" : "VkMemoryZirconHandlePropertiesFUCHSIA"), "pNext", indents, reinterpret_cast<const VkMemoryZirconHandlePropertiesFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_VkMemoryGetZirconHandleInfoFUCHSIA<Format>(*reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetZirconHandleInfoFUCHSIA*" : "VkMemoryGetZirconHandleInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_VkImportSemaphoreZirconHandleInfoFUCHSIA<Format>(*reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportSemaphoreZirconHandleInfoFUCHSIA*" : "VkImportSemaphoreZirconHandleInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
            dump_VkSemaphoreGetZirconHandleInfoFUCHSIA<Format>(*reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreGetZirconHandleInfoFUCHSIA*" : "VkSemaphoreGetZirconHandleInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA:
            dump_VkBufferCollectionCreateInfoFUCHSIA<Format>(*reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCollectionCreateInfoFUCHSIA*" : "VkBufferCollectionCreateInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
            dump_VkImportMemoryBufferCollectionFUCHSIA<Format>(*reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryBufferCollectionFUCHSIA*" : "VkImportMemoryBufferCollectionFUCHSIA"), "pNext", indents, reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
            dump_VkBufferCollectionImageCreateInfoFUCHSIA<Format>(*reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCollectionImageCreateInfoFUCHSIA*" : "VkBufferCollectionImageCreateInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA:
            dump_VkBufferCollectionConstraintsInfoFUCHSIA<Format>(*reinterpret_cast<const VkBufferCollectionConstraintsInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCollectionConstraintsInfoFUCHSIA*" : "VkBufferCollectionConstraintsInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkBufferCollectionConstraintsInfoFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA:
            dump_VkBufferConstraintsInfoFUCHSIA<Format>(*reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferConstraintsInfoFUCHSIA*" : "VkBufferConstraintsInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
            dump_VkBufferCollectionBufferCreateInfoFUCHSIA<Format>(*reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCollectionBufferCreateInfoFUCHSIA*" : "VkBufferCollectionBufferCreateInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA:
            dump_VkSysmemColorSpaceFUCHSIA<Format>(*reinterpret_cast<const VkSysmemColorSpaceFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSysmemColorSpaceFUCHSIA*" : "VkSysmemColorSpaceFUCHSIA"), "pNext", indents, reinterpret_cast<const VkSysmemColorSpaceFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA:
            dump_VkBufferCollectionPropertiesFUCHSIA<Format>(*reinterpret_cast<const VkBufferCollectionPropertiesFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCollectionPropertiesFUCHSIA*" : "VkBufferCollectionPropertiesFUCHSIA"), "pNext", indents, reinterpret_cast<const VkBufferCollectionPropertiesFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA:
            dump_VkImageFormatConstraintsInfoFUCHSIA<Format>(*reinterpret_cast<const VkImageFormatConstraintsInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageFormatConstraintsInfoFUCHSIA*" : "VkImageFormatConstraintsInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkImageFormatConstraintsInfoFUCHSIA*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA:
            dump_VkImageConstraintsInfoFUCHSIA<Format>(*reinterpret_cast<const VkImageConstraintsInfoFUCHSIA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageConstraintsInfoFUCHSIA*" : "VkImageConstraintsInfoFUCHSIA"), "pNext", indents, reinterpret_cast<const VkImageConstraintsInfoFUCHSIA*>(object));
            break;
#endif  // VK_USE_PLATFORM_FUCHSIA

        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
            dump_VkSubpassShadingPipelineCreateInfoHUAWEI<Format>(*reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassShadingPipelineCreateInfoHUAWEI*" : "VkSubpassShadingPipelineCreateInfoHUAWEI"), "pNext", indents, reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
            dump_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI<Format>(*reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*" : "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
            dump_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI<Format>(*reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*" : "VkPhysicalDeviceSubpassShadingPropertiesHUAWEI"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
            dump_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI<Format>(*reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*" : "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV:
            dump_VkMemoryGetRemoteAddressInfoNV<Format>(*reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetRemoteAddressInfoNV*" : "VkMemoryGetRemoteAddressInfoNV"), "pNext", indents, reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
            dump_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*" : "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT:
            dump_VkPipelinePropertiesIdentifierEXT<Format>(*reinterpret_cast<const VkPipelinePropertiesIdentifierEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelinePropertiesIdentifierEXT*" : "VkPipelinePropertiesIdentifierEXT"), "pNext", indents, reinterpret_cast<const VkPipelinePropertiesIdentifierEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
            dump_VkPhysicalDevicePipelinePropertiesFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelinePropertiesFeaturesEXT*" : "VkPhysicalDevicePipelinePropertiesFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
            dump_VkPhysicalDeviceFrameBoundaryFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFrameBoundaryFeaturesEXT*" : "VkPhysicalDeviceFrameBoundaryFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
            dump_VkFrameBoundaryEXT<Format>(*reinterpret_cast<const VkFrameBoundaryEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFrameBoundaryEXT*" : "VkFrameBoundaryEXT"), "pNext", indents, reinterpret_cast<const VkFrameBoundaryEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
            dump_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*" : "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
            dump_VkSubpassResolvePerformanceQueryEXT<Format>(*reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassResolvePerformanceQueryEXT*" : "VkSubpassResolvePerformanceQueryEXT"), "pNext", indents, reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
            dump_VkMultisampledRenderToSingleSampledInfoEXT<Format>(*reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMultisampledRenderToSingleSampledInfoEXT*" : "VkMultisampledRenderToSingleSampledInfoEXT"), "pNext", indents, reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
            dump_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*" : "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_SCREEN_QNX)

        case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX:
            dump_VkScreenSurfaceCreateInfoQNX<Format>(*reinterpret_cast<const VkScreenSurfaceCreateInfoQNX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkScreenSurfaceCreateInfoQNX*" : "VkScreenSurfaceCreateInfoQNX"), "pNext", indents, reinterpret_cast<const VkScreenSurfaceCreateInfoQNX*>(object));
            break;
#endif  // VK_USE_PLATFORM_SCREEN_QNX

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
            dump_VkPhysicalDeviceColorWriteEnableFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceColorWriteEnableFeaturesEXT*" : "VkPhysicalDeviceColorWriteEnableFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
            dump_VkPipelineColorWriteCreateInfoEXT<Format>(*reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineColorWriteCreateInfoEXT*" : "VkPipelineColorWriteCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
            dump_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*" : "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
            dump_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE<Format>(*reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*" : "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE:
            dump_VkVideoEncodeRgbConversionCapabilitiesVALVE<Format>(*reinterpret_cast<const VkVideoEncodeRgbConversionCapabilitiesVALVE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeRgbConversionCapabilitiesVALVE*" : "VkVideoEncodeRgbConversionCapabilitiesVALVE"), "pNext", indents, reinterpret_cast<const VkVideoEncodeRgbConversionCapabilitiesVALVE*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE:
            dump_VkVideoEncodeProfileRgbConversionInfoVALVE<Format>(*reinterpret_cast<const VkVideoEncodeProfileRgbConversionInfoVALVE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeProfileRgbConversionInfoVALVE*" : "VkVideoEncodeProfileRgbConversionInfoVALVE"), "pNext", indents, reinterpret_cast<const VkVideoEncodeProfileRgbConversionInfoVALVE*>(object));
            break;

        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE:
            dump_VkVideoEncodeSessionRgbConversionCreateInfoVALVE<Format>(*reinterpret_cast<const VkVideoEncodeSessionRgbConversionCreateInfoVALVE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeSessionRgbConversionCreateInfoVALVE*" : "VkVideoEncodeSessionRgbConversionCreateInfoVALVE"), "pNext", indents, reinterpret_cast<const VkVideoEncodeSessionRgbConversionCreateInfoVALVE*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
            dump_VkPhysicalDeviceImageViewMinLodFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageViewMinLodFeaturesEXT*" : "VkPhysicalDeviceImageViewMinLodFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
            dump_VkImageViewMinLodCreateInfoEXT<Format>(*reinterpret_cast<const VkImageViewMinLodCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewMinLodCreateInfoEXT*" : "VkImageViewMinLodCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkImageViewMinLodCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
            dump_VkPhysicalDeviceMultiDrawFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiDrawFeaturesEXT*" : "VkPhysicalDeviceMultiDrawFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
            dump_VkPhysicalDeviceMultiDrawPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiDrawPropertiesEXT*" : "VkPhysicalDeviceMultiDrawPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
            dump_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*" : "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderTileImageFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderTileImageFeaturesEXT*" : "VkPhysicalDeviceShaderTileImageFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
            dump_VkPhysicalDeviceShaderTileImagePropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderTileImagePropertiesEXT*" : "VkPhysicalDeviceShaderTileImagePropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT:
            dump_VkMicromapBuildInfoEXT<Format>(*reinterpret_cast<const VkMicromapBuildInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMicromapBuildInfoEXT*" : "VkMicromapBuildInfoEXT"), "pNext", indents, reinterpret_cast<const VkMicromapBuildInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT:
            dump_VkMicromapCreateInfoEXT<Format>(*reinterpret_cast<const VkMicromapCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMicromapCreateInfoEXT*" : "VkMicromapCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkMicromapCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
            dump_VkPhysicalDeviceOpacityMicromapFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceOpacityMicromapFeaturesEXT*" : "VkPhysicalDeviceOpacityMicromapFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
            dump_VkPhysicalDeviceOpacityMicromapPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceOpacityMicromapPropertiesEXT*" : "VkPhysicalDeviceOpacityMicromapPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT:
            dump_VkMicromapVersionInfoEXT<Format>(*reinterpret_cast<const VkMicromapVersionInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMicromapVersionInfoEXT*" : "VkMicromapVersionInfoEXT"), "pNext", indents, reinterpret_cast<const VkMicromapVersionInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT:
            dump_VkCopyMicromapToMemoryInfoEXT<Format>(*reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMicromapToMemoryInfoEXT*" : "VkCopyMicromapToMemoryInfoEXT"), "pNext", indents, reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT:
            dump_VkCopyMemoryToMicromapInfoEXT<Format>(*reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMemoryToMicromapInfoEXT*" : "VkCopyMemoryToMicromapInfoEXT"), "pNext", indents, reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT:
            dump_VkCopyMicromapInfoEXT<Format>(*reinterpret_cast<const VkCopyMicromapInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMicromapInfoEXT*" : "VkCopyMicromapInfoEXT"), "pNext", indents, reinterpret_cast<const VkCopyMicromapInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT:
            dump_VkMicromapBuildSizesInfoEXT<Format>(*reinterpret_cast<const VkMicromapBuildSizesInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMicromapBuildSizesInfoEXT*" : "VkMicromapBuildSizesInfoEXT"), "pNext", indents, reinterpret_cast<const VkMicromapBuildSizesInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
            dump_VkAccelerationStructureTrianglesOpacityMicromapEXT<Format>(*reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureTrianglesOpacityMicromapEXT*" : "VkAccelerationStructureTrianglesOpacityMicromapEXT"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT*>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV:
            dump_VkPhysicalDeviceDisplacementMicromapFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDisplacementMicromapFeaturesNV*" : "VkPhysicalDeviceDisplacementMicromapFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
            dump_VkPhysicalDeviceDisplacementMicromapPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDisplacementMicromapPropertiesNV*" : "VkPhysicalDeviceDisplacementMicromapPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
            dump_VkAccelerationStructureTrianglesDisplacementMicromapNV<Format>(*reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureTrianglesDisplacementMicromapNV*" : "VkAccelerationStructureTrianglesDisplacementMicromapNV"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV*>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
            dump_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI<Format>(*reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*" : "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
            dump_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI<Format>(*reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*" : "VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI:
            dump_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI<Format>(*reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI*" : "VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
            dump_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*" : "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
            dump_VkSamplerBorderColorComponentMappingCreateInfoEXT<Format>(*reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerBorderColorComponentMappingCreateInfoEXT*" : "VkSamplerBorderColorComponentMappingCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
            dump_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*" : "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
            dump_VkPhysicalDeviceShaderCorePropertiesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderCorePropertiesARM*" : "VkPhysicalDeviceShaderCorePropertiesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
            dump_VkDeviceQueueShaderCoreControlCreateInfoARM<Format>(*reinterpret_cast<const VkDeviceQueueShaderCoreControlCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceQueueShaderCoreControlCreateInfoARM*" : "VkDeviceQueueShaderCoreControlCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkDeviceQueueShaderCoreControlCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
            dump_VkPhysicalDeviceSchedulingControlsFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSchedulingControlsFeaturesARM*" : "VkPhysicalDeviceSchedulingControlsFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
            dump_VkPhysicalDeviceSchedulingControlsPropertiesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceSchedulingControlsPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSchedulingControlsPropertiesARM*" : "VkPhysicalDeviceSchedulingControlsPropertiesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSchedulingControlsPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPATCH_PARAMETERS_ARM:
            dump_VkDispatchParametersARM<Format>(*reinterpret_cast<const VkDispatchParametersARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDispatchParametersARM*" : "VkDispatchParametersARM"), "pNext", indents, reinterpret_cast<const VkDispatchParametersARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_PROPERTIES_ARM:
            dump_VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM*" : "VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
            dump_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*" : "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
            dump_VkImageViewSlicedCreateInfoEXT<Format>(*reinterpret_cast<const VkImageViewSlicedCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewSlicedCreateInfoEXT*" : "VkImageViewSlicedCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkImageViewSlicedCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
            dump_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*" : "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE:
            dump_VkDescriptorSetBindingReferenceVALVE<Format>(*reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetBindingReferenceVALVE*" : "VkDescriptorSetBindingReferenceVALVE"), "pNext", indents, reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE:
            dump_VkDescriptorSetLayoutHostMappingInfoVALVE<Format>(*reinterpret_cast<const VkDescriptorSetLayoutHostMappingInfoVALVE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetLayoutHostMappingInfoVALVE*" : "VkDescriptorSetLayoutHostMappingInfoVALVE"), "pNext", indents, reinterpret_cast<const VkDescriptorSetLayoutHostMappingInfoVALVE*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
            dump_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*" : "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
            dump_VkPhysicalDeviceRenderPassStripedFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRenderPassStripedFeaturesARM*" : "VkPhysicalDeviceRenderPassStripedFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
            dump_VkPhysicalDeviceRenderPassStripedPropertiesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceRenderPassStripedPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRenderPassStripedPropertiesARM*" : "VkPhysicalDeviceRenderPassStripedPropertiesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRenderPassStripedPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM:
            dump_VkRenderPassStripeInfoARM<Format>(*reinterpret_cast<const VkRenderPassStripeInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassStripeInfoARM*" : "VkRenderPassStripeInfoARM"), "pNext", indents, reinterpret_cast<const VkRenderPassStripeInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
            dump_VkRenderPassStripeBeginInfoARM<Format>(*reinterpret_cast<const VkRenderPassStripeBeginInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassStripeBeginInfoARM*" : "VkRenderPassStripeBeginInfoARM"), "pNext", indents, reinterpret_cast<const VkRenderPassStripeBeginInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
            dump_VkRenderPassStripeSubmitInfoARM<Format>(*reinterpret_cast<const VkRenderPassStripeSubmitInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassStripeSubmitInfoARM*" : "VkRenderPassStripeSubmitInfoARM"), "pNext", indents, reinterpret_cast<const VkRenderPassStripeSubmitInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
            dump_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*" : "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
            dump_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT*" : "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT:
            dump_VkRenderPassFragmentDensityMapOffsetEndInfoEXT<Format>(*reinterpret_cast<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassFragmentDensityMapOffsetEndInfoEXT*" : "VkRenderPassFragmentDensityMapOffsetEndInfoEXT"), "pNext", indents, reinterpret_cast<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
            dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*" : "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT:
            dump_VkPhysicalDeviceMemoryDecompressionFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMemoryDecompressionFeaturesEXT*" : "VkPhysicalDeviceMemoryDecompressionFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT:
            dump_VkPhysicalDeviceMemoryDecompressionPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMemoryDecompressionPropertiesEXT*" : "VkPhysicalDeviceMemoryDecompressionPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
            dump_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*" : "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
            dump_VkComputePipelineIndirectBufferInfoNV<Format>(*reinterpret_cast<const VkComputePipelineIndirectBufferInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkComputePipelineIndirectBufferInfoNV*" : "VkComputePipelineIndirectBufferInfoNV"), "pNext", indents, reinterpret_cast<const VkComputePipelineIndirectBufferInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV:
            dump_VkPipelineIndirectDeviceAddressInfoNV<Format>(*reinterpret_cast<const VkPipelineIndirectDeviceAddressInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineIndirectDeviceAddressInfoNV*" : "VkPipelineIndirectDeviceAddressInfoNV"), "pNext", indents, reinterpret_cast<const VkPipelineIndirectDeviceAddressInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
            dump_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*" : "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV:
            dump_VkAccelerationStructureGeometryLinearSweptSpheresDataNV<Format>(*reinterpret_cast<const VkAccelerationStructureGeometryLinearSweptSpheresDataNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryLinearSweptSpheresDataNV*" : "VkAccelerationStructureGeometryLinearSweptSpheresDataNV"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureGeometryLinearSweptSpheresDataNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV:
            dump_VkAccelerationStructureGeometrySpheresDataNV<Format>(*reinterpret_cast<const VkAccelerationStructureGeometrySpheresDataNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometrySpheresDataNV*" : "VkAccelerationStructureGeometrySpheresDataNV"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureGeometrySpheresDataNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
            dump_VkPhysicalDeviceLinearColorAttachmentFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLinearColorAttachmentFeaturesNV*" : "VkPhysicalDeviceLinearColorAttachmentFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
            dump_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*" : "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
            dump_VkImageViewSampleWeightCreateInfoQCOM<Format>(*reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewSampleWeightCreateInfoQCOM*" : "VkImageViewSampleWeightCreateInfoQCOM"), "pNext", indents, reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
            dump_VkPhysicalDeviceImageProcessingFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageProcessingFeaturesQCOM*" : "VkPhysicalDeviceImageProcessingFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
            dump_VkPhysicalDeviceImageProcessingPropertiesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageProcessingPropertiesQCOM*" : "VkPhysicalDeviceImageProcessingPropertiesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
            dump_VkPhysicalDeviceNestedCommandBufferFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceNestedCommandBufferFeaturesEXT*" : "VkPhysicalDeviceNestedCommandBufferFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
            dump_VkPhysicalDeviceNestedCommandBufferPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceNestedCommandBufferPropertiesEXT*" : "VkPhysicalDeviceNestedCommandBufferPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferPropertiesEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_OHOS)

        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS:
            dump_VkNativeBufferUsageOHOS<Format>(*reinterpret_cast<const VkNativeBufferUsageOHOS*>(object), settings, (Format == ApiDumpFormat::Json ? "VkNativeBufferUsageOHOS*" : "VkNativeBufferUsageOHOS"), "pNext", indents, reinterpret_cast<const VkNativeBufferUsageOHOS*>(object));
            break;

        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS:
            dump_VkNativeBufferPropertiesOHOS<Format>(*reinterpret_cast<const VkNativeBufferPropertiesOHOS*>(object), settings, (Format == ApiDumpFormat::Json ? "VkNativeBufferPropertiesOHOS*" : "VkNativeBufferPropertiesOHOS"), "pNext", indents, reinterpret_cast<const VkNativeBufferPropertiesOHOS*>(object));
            break;

        case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS:
            dump_VkNativeBufferFormatPropertiesOHOS<Format>(*reinterpret_cast<const VkNativeBufferFormatPropertiesOHOS*>(object), settings, (Format == ApiDumpFormat::Json ? "VkNativeBufferFormatPropertiesOHOS*" : "VkNativeBufferFormatPropertiesOHOS"), "pNext", indents, reinterpret_cast<const VkNativeBufferFormatPropertiesOHOS*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS:
            dump_VkImportNativeBufferInfoOHOS<Format>(*reinterpret_cast<const VkImportNativeBufferInfoOHOS*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportNativeBufferInfoOHOS*" : "VkImportNativeBufferInfoOHOS"), "pNext", indents, reinterpret_cast<const VkImportNativeBufferInfoOHOS*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS:
            dump_VkMemoryGetNativeBufferInfoOHOS<Format>(*reinterpret_cast<const VkMemoryGetNativeBufferInfoOHOS*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetNativeBufferInfoOHOS*" : "VkMemoryGetNativeBufferInfoOHOS"), "pNext", indents, reinterpret_cast<const VkMemoryGetNativeBufferInfoOHOS*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS:
            dump_VkExternalFormatOHOS<Format>(*reinterpret_cast<const VkExternalFormatOHOS*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalFormatOHOS*" : "VkExternalFormatOHOS"), "pNext", indents, reinterpret_cast<const VkExternalFormatOHOS*>(object));
            break;
#endif  // VK_USE_PLATFORM_OHOS

        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
            dump_VkExternalMemoryAcquireUnmodifiedEXT<Format>(*reinterpret_cast<const VkExternalMemoryAcquireUnmodifiedEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalMemoryAcquireUnmodifiedEXT*" : "VkExternalMemoryAcquireUnmodifiedEXT"), "pNext", indents, reinterpret_cast<const VkExternalMemoryAcquireUnmodifiedEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
            dump_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*" : "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
            dump_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*" : "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
            dump_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*" : "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
            dump_VkRenderPassCreationControlEXT<Format>(*reinterpret_cast<const VkRenderPassCreationControlEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassCreationControlEXT*" : "VkRenderPassCreationControlEXT"), "pNext", indents, reinterpret_cast<const VkRenderPassCreationControlEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
            dump_VkRenderPassCreationFeedbackCreateInfoEXT<Format>(*reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassCreationFeedbackCreateInfoEXT*" : "VkRenderPassCreationFeedbackCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
            dump_VkRenderPassSubpassFeedbackCreateInfoEXT<Format>(*reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassSubpassFeedbackCreateInfoEXT*" : "VkRenderPassSubpassFeedbackCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG:
            dump_VkDirectDriverLoadingInfoLUNARG<Format>(*reinterpret_cast<const VkDirectDriverLoadingInfoLUNARG*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDirectDriverLoadingInfoLUNARG*" : "VkDirectDriverLoadingInfoLUNARG"), "pNext", indents, reinterpret_cast<const VkDirectDriverLoadingInfoLUNARG*>(object));
            break;

        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
            dump_VkDirectDriverLoadingListLUNARG<Format>(*reinterpret_cast<const VkDirectDriverLoadingListLUNARG*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDirectDriverLoadingListLUNARG*" : "VkDirectDriverLoadingListLUNARG"), "pNext", indents, reinterpret_cast<const VkDirectDriverLoadingListLUNARG*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM:
            dump_VkTensorDescriptionARM<Format>(*reinterpret_cast<const VkTensorDescriptionARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorDescriptionARM*" : "VkTensorDescriptionARM"), "pNext", indents, reinterpret_cast<const VkTensorDescriptionARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM:
            dump_VkTensorCreateInfoARM<Format>(*reinterpret_cast<const VkTensorCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorCreateInfoARM*" : "VkTensorCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkTensorCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM:
            dump_VkTensorMemoryRequirementsInfoARM<Format>(*reinterpret_cast<const VkTensorMemoryRequirementsInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorMemoryRequirementsInfoARM*" : "VkTensorMemoryRequirementsInfoARM"), "pNext", indents, reinterpret_cast<const VkTensorMemoryRequirementsInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM:
            dump_VkBindTensorMemoryInfoARM<Format>(*reinterpret_cast<const VkBindTensorMemoryInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindTensorMemoryInfoARM*" : "VkBindTensorMemoryInfoARM"), "pNext", indents, reinterpret_cast<const VkBindTensorMemoryInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM:
            dump_VkWriteDescriptorSetTensorARM<Format>(*reinterpret_cast<const VkWriteDescriptorSetTensorARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSetTensorARM*" : "VkWriteDescriptorSetTensorARM"), "pNext", indents, reinterpret_cast<const VkWriteDescriptorSetTensorARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
            dump_VkTensorFormatPropertiesARM<Format>(*reinterpret_cast<const VkTensorFormatPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorFormatPropertiesARM*" : "VkTensorFormatPropertiesARM"), "pNext", indents, reinterpret_cast<const VkTensorFormatPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
            dump_VkPhysicalDeviceTensorPropertiesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceTensorPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTensorPropertiesARM*" : "VkPhysicalDeviceTensorPropertiesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTensorPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
            dump_VkTensorMemoryBarrierARM<Format>(*reinterpret_cast<const VkTensorMemoryBarrierARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorMemoryBarrierARM*" : "VkTensorMemoryBarrierARM"), "pNext", indents, reinterpret_cast<const VkTensorMemoryBarrierARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
            dump_VkTensorDependencyInfoARM<Format>(*reinterpret_cast<const VkTensorDependencyInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorDependencyInfoARM*" : "VkTensorDependencyInfoARM"), "pNext", indents, reinterpret_cast<const VkTensorDependencyInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
            dump_VkPhysicalDeviceTensorFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTensorFeaturesARM*" : "VkPhysicalDeviceTensorFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM:
            dump_VkDeviceTensorMemoryRequirementsARM<Format>(*reinterpret_cast<const VkDeviceTensorMemoryRequirementsARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceTensorMemoryRequirementsARM*" : "VkDeviceTensorMemoryRequirementsARM"), "pNext", indents, reinterpret_cast<const VkDeviceTensorMemoryRequirementsARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM:
            dump_VkTensorCopyARM<Format>(*reinterpret_cast<const VkTensorCopyARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorCopyARM*" : "VkTensorCopyARM"), "pNext", indents, reinterpret_cast<const VkTensorCopyARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM:
            dump_VkCopyTensorInfoARM<Format>(*reinterpret_cast<const VkCopyTensorInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyTensorInfoARM*" : "VkCopyTensorInfoARM"), "pNext", indents, reinterpret_cast<const VkCopyTensorInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
            dump_VkMemoryDedicatedAllocateInfoTensorARM<Format>(*reinterpret_cast<const VkMemoryDedicatedAllocateInfoTensorARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryDedicatedAllocateInfoTensorARM*" : "VkMemoryDedicatedAllocateInfoTensorARM"), "pNext", indents, reinterpret_cast<const VkMemoryDedicatedAllocateInfoTensorARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM:
            dump_VkPhysicalDeviceExternalTensorInfoARM<Format>(*reinterpret_cast<const VkPhysicalDeviceExternalTensorInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalTensorInfoARM*" : "VkPhysicalDeviceExternalTensorInfoARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExternalTensorInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM:
            dump_VkExternalTensorPropertiesARM<Format>(*reinterpret_cast<const VkExternalTensorPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalTensorPropertiesARM*" : "VkExternalTensorPropertiesARM"), "pNext", indents, reinterpret_cast<const VkExternalTensorPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
            dump_VkExternalMemoryTensorCreateInfoARM<Format>(*reinterpret_cast<const VkExternalMemoryTensorCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalMemoryTensorCreateInfoARM*" : "VkExternalMemoryTensorCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkExternalMemoryTensorCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
            dump_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*" : "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
            dump_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferTensorPropertiesARM*" : "VkPhysicalDeviceDescriptorBufferTensorPropertiesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM:
            dump_VkDescriptorGetTensorInfoARM<Format>(*reinterpret_cast<const VkDescriptorGetTensorInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorGetTensorInfoARM*" : "VkDescriptorGetTensorInfoARM"), "pNext", indents, reinterpret_cast<const VkDescriptorGetTensorInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
            dump_VkTensorCaptureDescriptorDataInfoARM<Format>(*reinterpret_cast<const VkTensorCaptureDescriptorDataInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorCaptureDescriptorDataInfoARM*" : "VkTensorCaptureDescriptorDataInfoARM"), "pNext", indents, reinterpret_cast<const VkTensorCaptureDescriptorDataInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
            dump_VkTensorViewCaptureDescriptorDataInfoARM<Format>(*reinterpret_cast<const VkTensorViewCaptureDescriptorDataInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorViewCaptureDescriptorDataInfoARM*" : "VkTensorViewCaptureDescriptorDataInfoARM"), "pNext", indents, reinterpret_cast<const VkTensorViewCaptureDescriptorDataInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
            dump_VkFrameBoundaryTensorsARM<Format>(*reinterpret_cast<const VkFrameBoundaryTensorsARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkFrameBoundaryTensorsARM*" : "VkFrameBoundaryTensorsARM"), "pNext", indents, reinterpret_cast<const VkFrameBoundaryTensorsARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*" : "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
            dump_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*" : "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
            dump_VkPipelineShaderStageModuleIdentifierCreateInfoEXT<Format>(*reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineShaderStageModuleIdentifierCreateInfoEXT*" : "VkPipelineShaderStageModuleIdentifierCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT:
            dump_VkShaderModuleIdentifierEXT<Format>(*reinterpret_cast<const VkShaderModuleIdentifierEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderModuleIdentifierEXT*" : "VkShaderModuleIdentifierEXT"), "pNext", indents, reinterpret_cast<const VkShaderModuleIdentifierEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
            dump_VkPhysicalDeviceOpticalFlowFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceOpticalFlowFeaturesNV*" : "VkPhysicalDeviceOpticalFlowFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
            dump_VkPhysicalDeviceOpticalFlowPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceOpticalFlowPropertiesNV*" : "VkPhysicalDeviceOpticalFlowPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
            dump_VkOpticalFlowImageFormatInfoNV<Format>(*reinterpret_cast<const VkOpticalFlowImageFormatInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkOpticalFlowImageFormatInfoNV*" : "VkOpticalFlowImageFormatInfoNV"), "pNext", indents, reinterpret_cast<const VkOpticalFlowImageFormatInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV:
            dump_VkOpticalFlowImageFormatPropertiesNV<Format>(*reinterpret_cast<const VkOpticalFlowImageFormatPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkOpticalFlowImageFormatPropertiesNV*" : "VkOpticalFlowImageFormatPropertiesNV"), "pNext", indents, reinterpret_cast<const VkOpticalFlowImageFormatPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV:
            dump_VkOpticalFlowSessionCreateInfoNV<Format>(*reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkOpticalFlowSessionCreateInfoNV*" : "VkOpticalFlowSessionCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
            dump_VkOpticalFlowSessionCreatePrivateDataInfoNV<Format>(*reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkOpticalFlowSessionCreatePrivateDataInfoNV*" : "VkOpticalFlowSessionCreatePrivateDataInfoNV"), "pNext", indents, reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV:
            dump_VkOpticalFlowExecuteInfoNV<Format>(*reinterpret_cast<const VkOpticalFlowExecuteInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkOpticalFlowExecuteInfoNV*" : "VkOpticalFlowExecuteInfoNV"), "pNext", indents, reinterpret_cast<const VkOpticalFlowExecuteInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
            dump_VkPhysicalDeviceLegacyDitheringFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLegacyDitheringFeaturesEXT*" : "VkPhysicalDeviceLegacyDitheringFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_ANDROID_KHR)

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
            dump_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID<Format>(*reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*" : "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
            dump_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID<Format>(*reinterpret_cast<const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalFormatResolvePropertiesANDROID*" : "VkPhysicalDeviceExternalFormatResolvePropertiesANDROID"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID*>(object));
            break;

        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
            dump_VkAndroidHardwareBufferFormatResolvePropertiesANDROID<Format>(*reinterpret_cast<const VkAndroidHardwareBufferFormatResolvePropertiesANDROID*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidHardwareBufferFormatResolvePropertiesANDROID*" : "VkAndroidHardwareBufferFormatResolvePropertiesANDROID"), "pNext", indents, reinterpret_cast<const VkAndroidHardwareBufferFormatResolvePropertiesANDROID*>(object));
            break;
#endif  // VK_USE_PLATFORM_ANDROID_KHR

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
            dump_VkPhysicalDeviceAntiLagFeaturesAMD<Format>(*reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAntiLagFeaturesAMD*" : "VkPhysicalDeviceAntiLagFeaturesAMD"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD:
            dump_VkAntiLagPresentationInfoAMD<Format>(*reinterpret_cast<const VkAntiLagPresentationInfoAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAntiLagPresentationInfoAMD*" : "VkAntiLagPresentationInfoAMD"), "pNext", indents, reinterpret_cast<const VkAntiLagPresentationInfoAMD*>(object));
            break;

        case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD:
            dump_VkAntiLagDataAMD<Format>(*reinterpret_cast<const VkAntiLagDataAMD*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAntiLagDataAMD*" : "VkAntiLagDataAMD"), "pNext", indents, reinterpret_cast<const VkAntiLagDataAMD*>(object));
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX:
            dump_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX<Format>(*reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX*" : "VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX:
            dump_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX<Format>(*reinterpret_cast<const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX*" : "VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX*>(object));
            break;
#endif  // VK_ENABLE_BETA_EXTENSIONS

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderObjectFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderObjectFeaturesEXT*" : "VkPhysicalDeviceShaderObjectFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
            dump_VkPhysicalDeviceShaderObjectPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderObjectPropertiesEXT*" : "VkPhysicalDeviceShaderObjectPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT:
            dump_VkShaderCreateInfoEXT<Format>(*reinterpret_cast<const VkShaderCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderCreateInfoEXT*" : "VkShaderCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkShaderCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
            dump_VkPhysicalDeviceTilePropertiesFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTilePropertiesFeaturesQCOM*" : "VkPhysicalDeviceTilePropertiesFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM:
            dump_VkTilePropertiesQCOM<Format>(*reinterpret_cast<const VkTilePropertiesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTilePropertiesQCOM*" : "VkTilePropertiesQCOM"), "pNext", indents, reinterpret_cast<const VkTilePropertiesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC:
            dump_VkPhysicalDeviceAmigoProfilingFeaturesSEC<Format>(*reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAmigoProfilingFeaturesSEC*" : "VkPhysicalDeviceAmigoProfilingFeaturesSEC"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(object));
            break;

        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
            dump_VkAmigoProfilingSubmitInfoSEC<Format>(*reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAmigoProfilingSubmitInfoSEC*" : "VkAmigoProfilingSubmitInfoSEC"), "pNext", indents, reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
            dump_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*" : "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
            dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*" : "VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
            dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*" : "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
            dump_VkPhysicalDeviceCooperativeVectorPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCooperativeVectorPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeVectorPropertiesNV*" : "VkPhysicalDeviceCooperativeVectorPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCooperativeVectorPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
            dump_VkPhysicalDeviceCooperativeVectorFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeVectorFeaturesNV*" : "VkPhysicalDeviceCooperativeVectorFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV:
            dump_VkCooperativeVectorPropertiesNV<Format>(*reinterpret_cast<const VkCooperativeVectorPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCooperativeVectorPropertiesNV*" : "VkCooperativeVectorPropertiesNV"), "pNext", indents, reinterpret_cast<const VkCooperativeVectorPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV:
            dump_VkConvertCooperativeVectorMatrixInfoNV<Format>(*reinterpret_cast<const VkConvertCooperativeVectorMatrixInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkConvertCooperativeVectorMatrixInfoNV*" : "VkConvertCooperativeVectorMatrixInfoNV"), "pNext", indents, reinterpret_cast<const VkConvertCooperativeVectorMatrixInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
            dump_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*" : "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
            dump_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV*" : "VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
            dump_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*" : "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
            dump_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT*" : "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
            dump_VkLayerSettingsCreateInfoEXT<Format>(*reinterpret_cast<const VkLayerSettingsCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkLayerSettingsCreateInfoEXT*" : "VkLayerSettingsCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkLayerSettingsCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
            dump_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*" : "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
            dump_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*" : "VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
            dump_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*" : "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
            dump_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*" : "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV:
            dump_VkLatencySleepModeInfoNV<Format>(*reinterpret_cast<const VkLatencySleepModeInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkLatencySleepModeInfoNV*" : "VkLatencySleepModeInfoNV"), "pNext", indents, reinterpret_cast<const VkLatencySleepModeInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV:
            dump_VkLatencySleepInfoNV<Format>(*reinterpret_cast<const VkLatencySleepInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkLatencySleepInfoNV*" : "VkLatencySleepInfoNV"), "pNext", indents, reinterpret_cast<const VkLatencySleepInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV:
            dump_VkSetLatencyMarkerInfoNV<Format>(*reinterpret_cast<const VkSetLatencyMarkerInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSetLatencyMarkerInfoNV*" : "VkSetLatencyMarkerInfoNV"), "pNext", indents, reinterpret_cast<const VkSetLatencyMarkerInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV:
            dump_VkLatencyTimingsFrameReportNV<Format>(*reinterpret_cast<const VkLatencyTimingsFrameReportNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkLatencyTimingsFrameReportNV*" : "VkLatencyTimingsFrameReportNV"), "pNext", indents, reinterpret_cast<const VkLatencyTimingsFrameReportNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV:
            dump_VkGetLatencyMarkerInfoNV<Format>(*reinterpret_cast<const VkGetLatencyMarkerInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGetLatencyMarkerInfoNV*" : "VkGetLatencyMarkerInfoNV"), "pNext", indents, reinterpret_cast<const VkGetLatencyMarkerInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
            dump_VkLatencySubmissionPresentIdNV<Format>(*reinterpret_cast<const VkLatencySubmissionPresentIdNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkLatencySubmissionPresentIdNV*" : "VkLatencySubmissionPresentIdNV"), "pNext", indents, reinterpret_cast<const VkLatencySubmissionPresentIdNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
            dump_VkSwapchainLatencyCreateInfoNV<Format>(*reinterpret_cast<const VkSwapchainLatencyCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainLatencyCreateInfoNV*" : "VkSwapchainLatencyCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkSwapchainLatencyCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV:
            dump_VkOutOfBandQueueTypeInfoNV<Format>(*reinterpret_cast<const VkOutOfBandQueueTypeInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkOutOfBandQueueTypeInfoNV*" : "VkOutOfBandQueueTypeInfoNV"), "pNext", indents, reinterpret_cast<const VkOutOfBandQueueTypeInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
            dump_VkLatencySurfaceCapabilitiesNV<Format>(*reinterpret_cast<const VkLatencySurfaceCapabilitiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkLatencySurfaceCapabilitiesNV*" : "VkLatencySurfaceCapabilitiesNV"), "pNext", indents, reinterpret_cast<const VkLatencySurfaceCapabilitiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM:
            dump_VkPhysicalDeviceDataGraphFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceDataGraphFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDataGraphFeaturesARM*" : "VkPhysicalDeviceDataGraphFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDataGraphFeaturesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM:
            dump_VkDataGraphPipelineConstantARM<Format>(*reinterpret_cast<const VkDataGraphPipelineConstantARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineConstantARM*" : "VkDataGraphPipelineConstantARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineConstantARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM:
            dump_VkDataGraphPipelineResourceInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineResourceInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineResourceInfoARM*" : "VkDataGraphPipelineResourceInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineResourceInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM:
            dump_VkDataGraphPipelineCompilerControlCreateInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineCompilerControlCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineCompilerControlCreateInfoARM*" : "VkDataGraphPipelineCompilerControlCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineCompilerControlCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM:
            dump_VkDataGraphPipelineCreateInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineCreateInfoARM*" : "VkDataGraphPipelineCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM:
            dump_VkDataGraphPipelineShaderModuleCreateInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineShaderModuleCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineShaderModuleCreateInfoARM*" : "VkDataGraphPipelineShaderModuleCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineShaderModuleCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM:
            dump_VkDataGraphPipelineSessionCreateInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineSessionCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineSessionCreateInfoARM*" : "VkDataGraphPipelineSessionCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineSessionCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM:
            dump_VkDataGraphPipelineSessionBindPointRequirementsInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineSessionBindPointRequirementsInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineSessionBindPointRequirementsInfoARM*" : "VkDataGraphPipelineSessionBindPointRequirementsInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineSessionBindPointRequirementsInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM:
            dump_VkDataGraphPipelineSessionBindPointRequirementARM<Format>(*reinterpret_cast<const VkDataGraphPipelineSessionBindPointRequirementARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineSessionBindPointRequirementARM*" : "VkDataGraphPipelineSessionBindPointRequirementARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineSessionBindPointRequirementARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM:
            dump_VkDataGraphPipelineSessionMemoryRequirementsInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineSessionMemoryRequirementsInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineSessionMemoryRequirementsInfoARM*" : "VkDataGraphPipelineSessionMemoryRequirementsInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineSessionMemoryRequirementsInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM:
            dump_VkBindDataGraphPipelineSessionMemoryInfoARM<Format>(*reinterpret_cast<const VkBindDataGraphPipelineSessionMemoryInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBindDataGraphPipelineSessionMemoryInfoARM*" : "VkBindDataGraphPipelineSessionMemoryInfoARM"), "pNext", indents, reinterpret_cast<const VkBindDataGraphPipelineSessionMemoryInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM:
            dump_VkDataGraphPipelineInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineInfoARM*" : "VkDataGraphPipelineInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM:
            dump_VkDataGraphPipelinePropertyQueryResultARM<Format>(*reinterpret_cast<const VkDataGraphPipelinePropertyQueryResultARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelinePropertyQueryResultARM*" : "VkDataGraphPipelinePropertyQueryResultARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelinePropertyQueryResultARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM:
            dump_VkDataGraphPipelineIdentifierCreateInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineIdentifierCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineIdentifierCreateInfoARM*" : "VkDataGraphPipelineIdentifierCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineIdentifierCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM:
            dump_VkDataGraphPipelineDispatchInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineDispatchInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineDispatchInfoARM*" : "VkDataGraphPipelineDispatchInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineDispatchInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM:
            dump_VkQueueFamilyDataGraphPropertiesARM<Format>(*reinterpret_cast<const VkQueueFamilyDataGraphPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyDataGraphPropertiesARM*" : "VkQueueFamilyDataGraphPropertiesARM"), "pNext", indents, reinterpret_cast<const VkQueueFamilyDataGraphPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM:
            dump_VkDataGraphProcessingEngineCreateInfoARM<Format>(*reinterpret_cast<const VkDataGraphProcessingEngineCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphProcessingEngineCreateInfoARM*" : "VkDataGraphProcessingEngineCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphProcessingEngineCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM:
            dump_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<Format>(*reinterpret_cast<const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM*" : "VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM:
            dump_VkQueueFamilyDataGraphProcessingEnginePropertiesARM<Format>(*reinterpret_cast<const VkQueueFamilyDataGraphProcessingEnginePropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyDataGraphProcessingEnginePropertiesARM*" : "VkQueueFamilyDataGraphProcessingEnginePropertiesARM"), "pNext", indents, reinterpret_cast<const VkQueueFamilyDataGraphProcessingEnginePropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM:
            dump_VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM*" : "VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_TOSA_PROPERTIES_ARM:
            dump_VkQueueFamilyDataGraphTOSAPropertiesARM<Format>(*reinterpret_cast<const VkQueueFamilyDataGraphTOSAPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyDataGraphTOSAPropertiesARM*" : "VkQueueFamilyDataGraphTOSAPropertiesARM"), "pNext", indents, reinterpret_cast<const VkQueueFamilyDataGraphTOSAPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
            dump_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*" : "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
            dump_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<Format>(*reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*" : "VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM"), "pNext", indents, reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
            dump_VkPhysicalDevicePerStageDescriptorSetFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePerStageDescriptorSetFeaturesNV*" : "VkPhysicalDevicePerStageDescriptorSetFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
            dump_VkPhysicalDeviceImageProcessing2FeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageProcessing2FeaturesQCOM*" : "VkPhysicalDeviceImageProcessing2FeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
            dump_VkPhysicalDeviceImageProcessing2PropertiesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceImageProcessing2PropertiesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageProcessing2PropertiesQCOM*" : "VkPhysicalDeviceImageProcessing2PropertiesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageProcessing2PropertiesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
            dump_VkSamplerBlockMatchWindowCreateInfoQCOM<Format>(*reinterpret_cast<const VkSamplerBlockMatchWindowCreateInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerBlockMatchWindowCreateInfoQCOM*" : "VkSamplerBlockMatchWindowCreateInfoQCOM"), "pNext", indents, reinterpret_cast<const VkSamplerBlockMatchWindowCreateInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
            dump_VkPhysicalDeviceCubicWeightsFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCubicWeightsFeaturesQCOM*" : "VkPhysicalDeviceCubicWeightsFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
            dump_VkSamplerCubicWeightsCreateInfoQCOM<Format>(*reinterpret_cast<const VkSamplerCubicWeightsCreateInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerCubicWeightsCreateInfoQCOM*" : "VkSamplerCubicWeightsCreateInfoQCOM"), "pNext", indents, reinterpret_cast<const VkSamplerCubicWeightsCreateInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM:
            dump_VkBlitImageCubicWeightsInfoQCOM<Format>(*reinterpret_cast<const VkBlitImageCubicWeightsInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBlitImageCubicWeightsInfoQCOM*" : "VkBlitImageCubicWeightsInfoQCOM"), "pNext", indents, reinterpret_cast<const VkBlitImageCubicWeightsInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
            dump_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*" : "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM:
            dump_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<Format>(*reinterpret_cast<const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM*" : "VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM"), "pNext", indents, reinterpret_cast<const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
            dump_VkPhysicalDeviceCubicClampFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCubicClampFeaturesQCOM*" : "VkPhysicalDeviceCubicClampFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
            dump_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*" : "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_SCREEN_QNX)

        case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX:
            dump_VkScreenBufferPropertiesQNX<Format>(*reinterpret_cast<const VkScreenBufferPropertiesQNX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkScreenBufferPropertiesQNX*" : "VkScreenBufferPropertiesQNX"), "pNext", indents, reinterpret_cast<const VkScreenBufferPropertiesQNX*>(object));
            break;

        case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
            dump_VkScreenBufferFormatPropertiesQNX<Format>(*reinterpret_cast<const VkScreenBufferFormatPropertiesQNX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkScreenBufferFormatPropertiesQNX*" : "VkScreenBufferFormatPropertiesQNX"), "pNext", indents, reinterpret_cast<const VkScreenBufferFormatPropertiesQNX*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX:
            dump_VkImportScreenBufferInfoQNX<Format>(*reinterpret_cast<const VkImportScreenBufferInfoQNX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportScreenBufferInfoQNX*" : "VkImportScreenBufferInfoQNX"), "pNext", indents, reinterpret_cast<const VkImportScreenBufferInfoQNX*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX:
            dump_VkExternalFormatQNX<Format>(*reinterpret_cast<const VkExternalFormatQNX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalFormatQNX*" : "VkExternalFormatQNX"), "pNext", indents, reinterpret_cast<const VkExternalFormatQNX*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX:
            dump_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<Format>(*reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*" : "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*>(object));
            break;
#endif  // VK_USE_PLATFORM_SCREEN_QNX

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
            dump_VkPhysicalDeviceLayeredDriverPropertiesMSFT<Format>(*reinterpret_cast<const VkPhysicalDeviceLayeredDriverPropertiesMSFT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLayeredDriverPropertiesMSFT*" : "VkPhysicalDeviceLayeredDriverPropertiesMSFT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceLayeredDriverPropertiesMSFT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
            dump_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*" : "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
            dump_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*" : "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
            dump_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTileMemoryHeapPropertiesQCOM*" : "VkPhysicalDeviceTileMemoryHeapPropertiesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
            dump_VkTileMemoryRequirementsQCOM<Format>(*reinterpret_cast<const VkTileMemoryRequirementsQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTileMemoryRequirementsQCOM*" : "VkTileMemoryRequirementsQCOM"), "pNext", indents, reinterpret_cast<const VkTileMemoryRequirementsQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
            dump_VkTileMemoryBindInfoQCOM<Format>(*reinterpret_cast<const VkTileMemoryBindInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTileMemoryBindInfoQCOM*" : "VkTileMemoryBindInfoQCOM"), "pNext", indents, reinterpret_cast<const VkTileMemoryBindInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
            dump_VkTileMemorySizeInfoQCOM<Format>(*reinterpret_cast<const VkTileMemorySizeInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTileMemorySizeInfoQCOM*" : "VkTileMemorySizeInfoQCOM"), "pNext", indents, reinterpret_cast<const VkTileMemorySizeInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT:
            dump_VkDecompressMemoryInfoEXT<Format>(*reinterpret_cast<const VkDecompressMemoryInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDecompressMemoryInfoEXT*" : "VkDecompressMemoryInfoEXT"), "pNext", indents, reinterpret_cast<const VkDecompressMemoryInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
            dump_VkDisplaySurfaceStereoCreateInfoNV<Format>(*reinterpret_cast<const VkDisplaySurfaceStereoCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplaySurfaceStereoCreateInfoNV*" : "VkDisplaySurfaceStereoCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkDisplaySurfaceStereoCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
            dump_VkDisplayModeStereoPropertiesNV<Format>(*reinterpret_cast<const VkDisplayModeStereoPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayModeStereoPropertiesNV*" : "VkDisplayModeStereoPropertiesNV"), "pNext", indents, reinterpret_cast<const VkDisplayModeStereoPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
            dump_VkPhysicalDeviceRawAccessChainsFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRawAccessChainsFeaturesNV*" : "VkPhysicalDeviceRawAccessChainsFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
            dump_VkExternalComputeQueueDeviceCreateInfoNV<Format>(*reinterpret_cast<const VkExternalComputeQueueDeviceCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalComputeQueueDeviceCreateInfoNV*" : "VkExternalComputeQueueDeviceCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkExternalComputeQueueDeviceCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV:
            dump_VkExternalComputeQueueCreateInfoNV<Format>(*reinterpret_cast<const VkExternalComputeQueueCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalComputeQueueCreateInfoNV*" : "VkExternalComputeQueueCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkExternalComputeQueueCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV:
            dump_VkExternalComputeQueueDataParamsNV<Format>(*reinterpret_cast<const VkExternalComputeQueueDataParamsNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalComputeQueueDataParamsNV*" : "VkExternalComputeQueueDataParamsNV"), "pNext", indents, reinterpret_cast<const VkExternalComputeQueueDataParamsNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
            dump_VkPhysicalDeviceExternalComputeQueuePropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceExternalComputeQueuePropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalComputeQueuePropertiesNV*" : "VkPhysicalDeviceExternalComputeQueuePropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceExternalComputeQueuePropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
            dump_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*" : "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
            dump_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*" : "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*" : "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_ROLLING_BACKING_CREATE_INFO_ARM:
            dump_VkTensorRollingBackingCreateInfoARM<Format>(*reinterpret_cast<const VkTensorRollingBackingCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorRollingBackingCreateInfoARM*" : "VkTensorRollingBackingCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkTensorRollingBackingCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_TENSOR_EXPLICIT_TILING_FORMAT_PROPERTIES_ARM:
            dump_VkTensorExplicitTilingFormatPropertiesARM<Format>(*reinterpret_cast<const VkTensorExplicitTilingFormatPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorExplicitTilingFormatPropertiesARM*" : "VkTensorExplicitTilingFormatPropertiesARM"), "pNext", indents, reinterpret_cast<const VkTensorExplicitTilingFormatPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderFloat8FeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderFloat8FeaturesEXT*" : "VkPhysicalDeviceShaderFloat8FeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
            dump_VkPhysicalDeviceRayTracingValidationFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingValidationFeaturesNV*" : "VkPhysicalDeviceRayTracingValidationFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
            dump_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*" : "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
            dump_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceClusterAccelerationStructurePropertiesNV*" : "VkPhysicalDeviceClusterAccelerationStructurePropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV:
            dump_VkClusterAccelerationStructureClustersBottomLevelInputNV<Format>(*reinterpret_cast<const VkClusterAccelerationStructureClustersBottomLevelInputNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkClusterAccelerationStructureClustersBottomLevelInputNV*" : "VkClusterAccelerationStructureClustersBottomLevelInputNV"), "pNext", indents, reinterpret_cast<const VkClusterAccelerationStructureClustersBottomLevelInputNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV:
            dump_VkClusterAccelerationStructureTriangleClusterInputNV<Format>(*reinterpret_cast<const VkClusterAccelerationStructureTriangleClusterInputNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkClusterAccelerationStructureTriangleClusterInputNV*" : "VkClusterAccelerationStructureTriangleClusterInputNV"), "pNext", indents, reinterpret_cast<const VkClusterAccelerationStructureTriangleClusterInputNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV:
            dump_VkClusterAccelerationStructureMoveObjectsInputNV<Format>(*reinterpret_cast<const VkClusterAccelerationStructureMoveObjectsInputNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkClusterAccelerationStructureMoveObjectsInputNV*" : "VkClusterAccelerationStructureMoveObjectsInputNV"), "pNext", indents, reinterpret_cast<const VkClusterAccelerationStructureMoveObjectsInputNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV:
            dump_VkClusterAccelerationStructureInputInfoNV<Format>(*reinterpret_cast<const VkClusterAccelerationStructureInputInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkClusterAccelerationStructureInputInfoNV*" : "VkClusterAccelerationStructureInputInfoNV"), "pNext", indents, reinterpret_cast<const VkClusterAccelerationStructureInputInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV:
            dump_VkClusterAccelerationStructureCommandsInfoNV<Format>(*reinterpret_cast<const VkClusterAccelerationStructureCommandsInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkClusterAccelerationStructureCommandsInfoNV*" : "VkClusterAccelerationStructureCommandsInfoNV"), "pNext", indents, reinterpret_cast<const VkClusterAccelerationStructureCommandsInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR:
            dump_VkAccelerationStructureBuildSizesInfoKHR<Format>(*reinterpret_cast<const VkAccelerationStructureBuildSizesInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureBuildSizesInfoKHR*" : "VkAccelerationStructureBuildSizesInfoKHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureBuildSizesInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
            dump_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV<Format>(*reinterpret_cast<const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV*" : "VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV"), "pNext", indents, reinterpret_cast<const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
            dump_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*" : "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
            dump_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV*" : "VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
            dump_VkPartitionedAccelerationStructureFlagsNV<Format>(*reinterpret_cast<const VkPartitionedAccelerationStructureFlagsNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPartitionedAccelerationStructureFlagsNV*" : "VkPartitionedAccelerationStructureFlagsNV"), "pNext", indents, reinterpret_cast<const VkPartitionedAccelerationStructureFlagsNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
            dump_VkWriteDescriptorSetPartitionedAccelerationStructureNV<Format>(*reinterpret_cast<const VkWriteDescriptorSetPartitionedAccelerationStructureNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSetPartitionedAccelerationStructureNV*" : "VkWriteDescriptorSetPartitionedAccelerationStructureNV"), "pNext", indents, reinterpret_cast<const VkWriteDescriptorSetPartitionedAccelerationStructureNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV:
            dump_VkPartitionedAccelerationStructureInstancesInputNV<Format>(*reinterpret_cast<const VkPartitionedAccelerationStructureInstancesInputNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPartitionedAccelerationStructureInstancesInputNV*" : "VkPartitionedAccelerationStructureInstancesInputNV"), "pNext", indents, reinterpret_cast<const VkPartitionedAccelerationStructureInstancesInputNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV:
            dump_VkBuildPartitionedAccelerationStructureInfoNV<Format>(*reinterpret_cast<const VkBuildPartitionedAccelerationStructureInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBuildPartitionedAccelerationStructureInfoNV*" : "VkBuildPartitionedAccelerationStructureInfoNV"), "pNext", indents, reinterpret_cast<const VkBuildPartitionedAccelerationStructureInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
            dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*" : "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
            dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT*" : "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT:
            dump_VkGeneratedCommandsMemoryRequirementsInfoEXT<Format>(*reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsMemoryRequirementsInfoEXT*" : "VkGeneratedCommandsMemoryRequirementsInfoEXT"), "pNext", indents, reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT:
            dump_VkIndirectExecutionSetPipelineInfoEXT<Format>(*reinterpret_cast<const VkIndirectExecutionSetPipelineInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectExecutionSetPipelineInfoEXT*" : "VkIndirectExecutionSetPipelineInfoEXT"), "pNext", indents, reinterpret_cast<const VkIndirectExecutionSetPipelineInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT:
            dump_VkIndirectExecutionSetShaderLayoutInfoEXT<Format>(*reinterpret_cast<const VkIndirectExecutionSetShaderLayoutInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectExecutionSetShaderLayoutInfoEXT*" : "VkIndirectExecutionSetShaderLayoutInfoEXT"), "pNext", indents, reinterpret_cast<const VkIndirectExecutionSetShaderLayoutInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT:
            dump_VkIndirectExecutionSetShaderInfoEXT<Format>(*reinterpret_cast<const VkIndirectExecutionSetShaderInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectExecutionSetShaderInfoEXT*" : "VkIndirectExecutionSetShaderInfoEXT"), "pNext", indents, reinterpret_cast<const VkIndirectExecutionSetShaderInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT:
            dump_VkIndirectExecutionSetCreateInfoEXT<Format>(*reinterpret_cast<const VkIndirectExecutionSetCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectExecutionSetCreateInfoEXT*" : "VkIndirectExecutionSetCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkIndirectExecutionSetCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT:
            dump_VkGeneratedCommandsInfoEXT<Format>(*reinterpret_cast<const VkGeneratedCommandsInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsInfoEXT*" : "VkGeneratedCommandsInfoEXT"), "pNext", indents, reinterpret_cast<const VkGeneratedCommandsInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT:
            dump_VkWriteIndirectExecutionSetPipelineEXT<Format>(*reinterpret_cast<const VkWriteIndirectExecutionSetPipelineEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteIndirectExecutionSetPipelineEXT*" : "VkWriteIndirectExecutionSetPipelineEXT"), "pNext", indents, reinterpret_cast<const VkWriteIndirectExecutionSetPipelineEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT:
            dump_VkIndirectCommandsLayoutTokenEXT<Format>(*reinterpret_cast<const VkIndirectCommandsLayoutTokenEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectCommandsLayoutTokenEXT*" : "VkIndirectCommandsLayoutTokenEXT"), "pNext", indents, reinterpret_cast<const VkIndirectCommandsLayoutTokenEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT:
            dump_VkIndirectCommandsLayoutCreateInfoEXT<Format>(*reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectCommandsLayoutCreateInfoEXT*" : "VkIndirectCommandsLayoutCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT:
            dump_VkGeneratedCommandsPipelineInfoEXT<Format>(*reinterpret_cast<const VkGeneratedCommandsPipelineInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsPipelineInfoEXT*" : "VkGeneratedCommandsPipelineInfoEXT"), "pNext", indents, reinterpret_cast<const VkGeneratedCommandsPipelineInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
            dump_VkGeneratedCommandsShaderInfoEXT<Format>(*reinterpret_cast<const VkGeneratedCommandsShaderInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsShaderInfoEXT*" : "VkGeneratedCommandsShaderInfoEXT"), "pNext", indents, reinterpret_cast<const VkGeneratedCommandsShaderInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT:
            dump_VkWriteIndirectExecutionSetShaderEXT<Format>(*reinterpret_cast<const VkWriteIndirectExecutionSetShaderEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteIndirectExecutionSetShaderEXT*" : "VkWriteIndirectExecutionSetShaderEXT"), "pNext", indents, reinterpret_cast<const VkWriteIndirectExecutionSetShaderEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
            dump_VkPhysicalDeviceImageAlignmentControlFeaturesMESA<Format>(*reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageAlignmentControlFeaturesMESA*" : "VkPhysicalDeviceImageAlignmentControlFeaturesMESA"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
            dump_VkPhysicalDeviceImageAlignmentControlPropertiesMESA<Format>(*reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlPropertiesMESA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageAlignmentControlPropertiesMESA*" : "VkPhysicalDeviceImageAlignmentControlPropertiesMESA"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlPropertiesMESA*>(object));
            break;

        case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
            dump_VkImageAlignmentControlCreateInfoMESA<Format>(*reinterpret_cast<const VkImageAlignmentControlCreateInfoMESA*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImageAlignmentControlCreateInfoMESA*" : "VkImageAlignmentControlCreateInfoMESA"), "pNext", indents, reinterpret_cast<const VkImageAlignmentControlCreateInfoMESA*>(object));
            break;

        case VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV:
            dump_VkPushConstantBankInfoNV<Format>(*reinterpret_cast<const VkPushConstantBankInfoNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPushConstantBankInfoNV*" : "VkPushConstantBankInfoNV"), "pNext", indents, reinterpret_cast<const VkPushConstantBankInfoNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV:
            dump_VkPhysicalDevicePushConstantBankFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDevicePushConstantBankFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePushConstantBankFeaturesNV*" : "VkPhysicalDevicePushConstantBankFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePushConstantBankFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV:
            dump_VkPhysicalDevicePushConstantBankPropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDevicePushConstantBankPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePushConstantBankPropertiesNV*" : "VkPhysicalDevicePushConstantBankPropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePushConstantBankPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT:
            dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT*" : "VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT:
            dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*" : "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
            dump_VkPhysicalDeviceDepthClampControlFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthClampControlFeaturesEXT*" : "VkPhysicalDeviceDepthClampControlFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
            dump_VkPipelineViewportDepthClampControlCreateInfoEXT<Format>(*reinterpret_cast<const VkPipelineViewportDepthClampControlCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportDepthClampControlCreateInfoEXT*" : "VkPipelineViewportDepthClampControlCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkPipelineViewportDepthClampControlCreateInfoEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_OHOS)

        case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS:
            dump_VkSurfaceCreateInfoOHOS<Format>(*reinterpret_cast<const VkSurfaceCreateInfoOHOS*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCreateInfoOHOS*" : "VkSurfaceCreateInfoOHOS"), "pNext", indents, reinterpret_cast<const VkSurfaceCreateInfoOHOS*>(object));
            break;
#endif  // VK_USE_PLATFORM_OHOS

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
            dump_VkPhysicalDeviceHdrVividFeaturesHUAWEI<Format>(*reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceHdrVividFeaturesHUAWEI*" : "VkPhysicalDeviceHdrVividFeaturesHUAWEI"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI*>(object));
            break;

        case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI:
            dump_VkHdrVividDynamicMetadataHUAWEI<Format>(*reinterpret_cast<const VkHdrVividDynamicMetadataHUAWEI*>(object), settings, (Format == ApiDumpFormat::Json ? "VkHdrVividDynamicMetadataHUAWEI*" : "VkHdrVividDynamicMetadataHUAWEI"), "pNext", indents, reinterpret_cast<const VkHdrVividDynamicMetadataHUAWEI*>(object));
            break;

        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV:
            dump_VkCooperativeMatrixFlexibleDimensionsPropertiesNV<Format>(*reinterpret_cast<const VkCooperativeMatrixFlexibleDimensionsPropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCooperativeMatrixFlexibleDimensionsPropertiesNV*" : "VkCooperativeMatrixFlexibleDimensionsPropertiesNV"), "pNext", indents, reinterpret_cast<const VkCooperativeMatrixFlexibleDimensionsPropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
            dump_VkPhysicalDeviceCooperativeMatrix2FeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrix2FeaturesNV*" : "VkPhysicalDeviceCooperativeMatrix2FeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
            dump_VkPhysicalDeviceCooperativeMatrix2PropertiesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrix2PropertiesNV*" : "VkPhysicalDeviceCooperativeMatrix2PropertiesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
            dump_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*" : "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*>(object));
            break;
#if defined(VK_USE_PLATFORM_METAL_EXT)

        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT:
            dump_VkImportMemoryMetalHandleInfoEXT<Format>(*reinterpret_cast<const VkImportMemoryMetalHandleInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryMetalHandleInfoEXT*" : "VkImportMemoryMetalHandleInfoEXT"), "pNext", indents, reinterpret_cast<const VkImportMemoryMetalHandleInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT:
            dump_VkMemoryMetalHandlePropertiesEXT<Format>(*reinterpret_cast<const VkMemoryMetalHandlePropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryMetalHandlePropertiesEXT*" : "VkMemoryMetalHandlePropertiesEXT"), "pNext", indents, reinterpret_cast<const VkMemoryMetalHandlePropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT:
            dump_VkMemoryGetMetalHandleInfoEXT<Format>(*reinterpret_cast<const VkMemoryGetMetalHandleInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetMetalHandleInfoEXT*" : "VkMemoryGetMetalHandleInfoEXT"), "pNext", indents, reinterpret_cast<const VkMemoryGetMetalHandleInfoEXT*>(object));
            break;
#endif  // VK_USE_PLATFORM_METAL_EXT

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM:
            dump_VkPhysicalDevicePerformanceCountersByRegionFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePerformanceCountersByRegionFeaturesARM*" : "VkPhysicalDevicePerformanceCountersByRegionFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM:
            dump_VkPhysicalDevicePerformanceCountersByRegionPropertiesARM<Format>(*reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePerformanceCountersByRegionPropertiesARM*" : "VkPhysicalDevicePerformanceCountersByRegionPropertiesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePerformanceCountersByRegionPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM:
            dump_VkPerformanceCounterARM<Format>(*reinterpret_cast<const VkPerformanceCounterARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceCounterARM*" : "VkPerformanceCounterARM"), "pNext", indents, reinterpret_cast<const VkPerformanceCounterARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM:
            dump_VkPerformanceCounterDescriptionARM<Format>(*reinterpret_cast<const VkPerformanceCounterDescriptionARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceCounterDescriptionARM*" : "VkPerformanceCounterDescriptionARM"), "pNext", indents, reinterpret_cast<const VkPerformanceCounterDescriptionARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM:
            dump_VkRenderPassPerformanceCountersByRegionBeginInfoARM<Format>(*reinterpret_cast<const VkRenderPassPerformanceCountersByRegionBeginInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassPerformanceCountersByRegionBeginInfoARM*" : "VkRenderPassPerformanceCountersByRegionBeginInfoARM"), "pNext", indents, reinterpret_cast<const VkRenderPassPerformanceCountersByRegionBeginInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM:
            dump_VkPhysicalDeviceShaderInstrumentationFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderInstrumentationFeaturesARM*" : "VkPhysicalDeviceShaderInstrumentationFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationFeaturesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM:
            dump_VkPhysicalDeviceShaderInstrumentationPropertiesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderInstrumentationPropertiesARM*" : "VkPhysicalDeviceShaderInstrumentationPropertiesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderInstrumentationPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM:
            dump_VkShaderInstrumentationCreateInfoARM<Format>(*reinterpret_cast<const VkShaderInstrumentationCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderInstrumentationCreateInfoARM*" : "VkShaderInstrumentationCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkShaderInstrumentationCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM:
            dump_VkShaderInstrumentationMetricDescriptionARM<Format>(*reinterpret_cast<const VkShaderInstrumentationMetricDescriptionARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderInstrumentationMetricDescriptionARM*" : "VkShaderInstrumentationMetricDescriptionARM"), "pNext", indents, reinterpret_cast<const VkShaderInstrumentationMetricDescriptionARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
            dump_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*" : "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
            dump_VkPhysicalDeviceFormatPackFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFormatPackFeaturesARM*" : "VkPhysicalDeviceFormatPackFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE:
            dump_VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*" : "VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE:
            dump_VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE<Format>(*reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE*" : "VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE*>(object));
            break;

        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE:
            dump_VkPipelineFragmentDensityMapLayeredCreateInfoVALVE<Format>(*reinterpret_cast<const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*" : "VkPipelineFragmentDensityMapLayeredCreateInfoVALVE"), "pNext", indents, reinterpret_cast<const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*>(object));
            break;

        case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
            dump_VkSetPresentConfigNV<Format>(*reinterpret_cast<const VkSetPresentConfigNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSetPresentConfigNV*" : "VkSetPresentConfigNV"), "pNext", indents, reinterpret_cast<const VkSetPresentConfigNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
            dump_VkPhysicalDevicePresentMeteringFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentMeteringFeaturesNV*" : "VkPhysicalDevicePresentMeteringFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT:
            dump_VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT*" : "VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT:
            dump_VkSwapchainFlagsSurfaceCapabilitiesEXT<Format>(*reinterpret_cast<const VkSwapchainFlagsSurfaceCapabilitiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainFlagsSurfaceCapabilitiesEXT*" : "VkSwapchainFlagsSurfaceCapabilitiesEXT"), "pNext", indents, reinterpret_cast<const VkSwapchainFlagsSurfaceCapabilitiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
            dump_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*" : "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT:
            dump_VkPhysicalDeviceShader64BitIndexingFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShader64BitIndexingFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShader64BitIndexingFeaturesEXT*" : "VkPhysicalDeviceShader64BitIndexingFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShader64BitIndexingFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT:
            dump_VkPhysicalDeviceCustomResolveFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceCustomResolveFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCustomResolveFeaturesEXT*" : "VkPhysicalDeviceCustomResolveFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCustomResolveFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT:
            dump_VkBeginCustomResolveInfoEXT<Format>(*reinterpret_cast<const VkBeginCustomResolveInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkBeginCustomResolveInfoEXT*" : "VkBeginCustomResolveInfoEXT"), "pNext", indents, reinterpret_cast<const VkBeginCustomResolveInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT:
            dump_VkCustomResolveCreateInfoEXT<Format>(*reinterpret_cast<const VkCustomResolveCreateInfoEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCustomResolveCreateInfoEXT*" : "VkCustomResolveCreateInfoEXT"), "pNext", indents, reinterpret_cast<const VkCustomResolveCreateInfoEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM:
            dump_VkDataGraphPipelineBuiltinModelCreateInfoQCOM<Format>(*reinterpret_cast<const VkDataGraphPipelineBuiltinModelCreateInfoQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineBuiltinModelCreateInfoQCOM*" : "VkDataGraphPipelineBuiltinModelCreateInfoQCOM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineBuiltinModelCreateInfoQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM:
            dump_VkPhysicalDeviceDataGraphModelFeaturesQCOM<Format>(*reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDataGraphModelFeaturesQCOM*" : "VkPhysicalDeviceDataGraphModelFeaturesQCOM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM:
            dump_VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM*" : "VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM:
            dump_VkQueueFamilyDataGraphOpticalFlowPropertiesARM<Format>(*reinterpret_cast<const VkQueueFamilyDataGraphOpticalFlowPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyDataGraphOpticalFlowPropertiesARM*" : "VkQueueFamilyDataGraphOpticalFlowPropertiesARM"), "pNext", indents, reinterpret_cast<const VkQueueFamilyDataGraphOpticalFlowPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM:
            dump_VkDataGraphPipelineOpticalFlowCreateInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineOpticalFlowCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineOpticalFlowCreateInfoARM*" : "VkDataGraphPipelineOpticalFlowCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineOpticalFlowCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM:
            dump_VkDataGraphOpticalFlowImageFormatPropertiesARM<Format>(*reinterpret_cast<const VkDataGraphOpticalFlowImageFormatPropertiesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphOpticalFlowImageFormatPropertiesARM*" : "VkDataGraphOpticalFlowImageFormatPropertiesARM"), "pNext", indents, reinterpret_cast<const VkDataGraphOpticalFlowImageFormatPropertiesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM:
            dump_VkDataGraphOpticalFlowImageFormatInfoARM<Format>(*reinterpret_cast<const VkDataGraphOpticalFlowImageFormatInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphOpticalFlowImageFormatInfoARM*" : "VkDataGraphOpticalFlowImageFormatInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphOpticalFlowImageFormatInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM:
            dump_VkDataGraphPipelineOpticalFlowDispatchInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineOpticalFlowDispatchInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineOpticalFlowDispatchInfoARM*" : "VkDataGraphPipelineOpticalFlowDispatchInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineOpticalFlowDispatchInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM:
            dump_VkDataGraphPipelineResourceInfoImageLayoutARM<Format>(*reinterpret_cast<const VkDataGraphPipelineResourceInfoImageLayoutARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineResourceInfoImageLayoutARM*" : "VkDataGraphPipelineResourceInfoImageLayoutARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineResourceInfoImageLayoutARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM:
            dump_VkDataGraphPipelineSingleNodeConnectionARM<Format>(*reinterpret_cast<const VkDataGraphPipelineSingleNodeConnectionARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineSingleNodeConnectionARM*" : "VkDataGraphPipelineSingleNodeConnectionARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineSingleNodeConnectionARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM:
            dump_VkDataGraphPipelineSingleNodeCreateInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineSingleNodeCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineSingleNodeCreateInfoARM*" : "VkDataGraphPipelineSingleNodeCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineSingleNodeCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderLongVectorFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderLongVectorFeaturesEXT*" : "VkPhysicalDeviceShaderLongVectorFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderLongVectorFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT:
            dump_VkPhysicalDeviceShaderLongVectorPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderLongVectorPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderLongVectorPropertiesEXT*" : "VkPhysicalDeviceShaderLongVectorPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderLongVectorPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC:
            dump_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC<Format>(*reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*" : "VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*" : "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV:
            dump_VkComputeOccupancyPriorityParametersNV<Format>(*reinterpret_cast<const VkComputeOccupancyPriorityParametersNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkComputeOccupancyPriorityParametersNV*" : "VkComputeOccupancyPriorityParametersNV"), "pNext", indents, reinterpret_cast<const VkComputeOccupancyPriorityParametersNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV:
            dump_VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV*" : "VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*" : "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*>(object));
            break;
#if defined(VK_USE_PLATFORM_UBM_SEC)

        case VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC:
            dump_VkUbmSurfaceCreateInfoSEC<Format>(*reinterpret_cast<const VkUbmSurfaceCreateInfoSEC*>(object), settings, (Format == ApiDumpFormat::Json ? "VkUbmSurfaceCreateInfoSEC*" : "VkUbmSurfaceCreateInfoSEC"), "pNext", indents, reinterpret_cast<const VkUbmSurfaceCreateInfoSEC*>(object));
            break;
#endif  // VK_USE_PLATFORM_UBM_SEC

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OCP_MICROSCALING_TYPES_FEATURES_EXT:
            dump_VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT*" : "VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderOCPMicroscalingTypesFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE:
            dump_VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE<Format>(*reinterpret_cast<const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*" : "VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE*>(object));
            break;

        case VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC:
            dump_VkThrottleHintSubmitInfoSEC<Format>(*reinterpret_cast<const VkThrottleHintSubmitInfoSEC*>(object), settings, (Format == ApiDumpFormat::Json ? "VkThrottleHintSubmitInfoSEC*" : "VkThrottleHintSubmitInfoSEC"), "pNext", indents, reinterpret_cast<const VkThrottleHintSubmitInfoSEC*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC:
            dump_VkPhysicalDeviceThrottleHintFeaturesSEC<Format>(*reinterpret_cast<const VkPhysicalDeviceThrottleHintFeaturesSEC*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceThrottleHintFeaturesSEC*" : "VkPhysicalDeviceThrottleHintFeaturesSEC"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceThrottleHintFeaturesSEC*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM:
            dump_VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM<Format>(*reinterpret_cast<const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM*" : "VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM:
            dump_VkDataGraphPipelineNeuralStatisticsCreateInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineNeuralStatisticsCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineNeuralStatisticsCreateInfoARM*" : "VkDataGraphPipelineNeuralStatisticsCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineNeuralStatisticsCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM:
            dump_VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM<Format>(*reinterpret_cast<const VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM*>(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM*" : "VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM"), "pNext", indents, reinterpret_cast<const VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT:
            dump_VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT*" : "VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDevicePrimitiveRestartIndexFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV:
            dump_VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV<Format>(*reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV*" : "VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR:
            dump_VkAccelerationStructureGeometryTrianglesDataKHR<Format>(*reinterpret_cast<const VkAccelerationStructureGeometryTrianglesDataKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryTrianglesDataKHR*" : "VkAccelerationStructureGeometryTrianglesDataKHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureGeometryTrianglesDataKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR:
            dump_VkAccelerationStructureGeometryAabbsDataKHR<Format>(*reinterpret_cast<const VkAccelerationStructureGeometryAabbsDataKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryAabbsDataKHR*" : "VkAccelerationStructureGeometryAabbsDataKHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureGeometryAabbsDataKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR:
            dump_VkAccelerationStructureGeometryInstancesDataKHR<Format>(*reinterpret_cast<const VkAccelerationStructureGeometryInstancesDataKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryInstancesDataKHR*" : "VkAccelerationStructureGeometryInstancesDataKHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureGeometryInstancesDataKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR:
            dump_VkAccelerationStructureGeometryKHR<Format>(*reinterpret_cast<const VkAccelerationStructureGeometryKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryKHR*" : "VkAccelerationStructureGeometryKHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureGeometryKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR:
            dump_VkAccelerationStructureBuildGeometryInfoKHR<Format>(*reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureBuildGeometryInfoKHR*" : "VkAccelerationStructureBuildGeometryInfoKHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR:
            dump_VkAccelerationStructureCreateInfoKHR<Format>(*reinterpret_cast<const VkAccelerationStructureCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureCreateInfoKHR*" : "VkAccelerationStructureCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
            dump_VkWriteDescriptorSetAccelerationStructureKHR<Format>(*reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSetAccelerationStructureKHR*" : "VkWriteDescriptorSetAccelerationStructureKHR"), "pNext", indents, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
            dump_VkPhysicalDeviceAccelerationStructureFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAccelerationStructureFeaturesKHR*" : "VkPhysicalDeviceAccelerationStructureFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
            dump_VkPhysicalDeviceAccelerationStructurePropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAccelerationStructurePropertiesKHR*" : "VkPhysicalDeviceAccelerationStructurePropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR:
            dump_VkAccelerationStructureDeviceAddressInfoKHR<Format>(*reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureDeviceAddressInfoKHR*" : "VkAccelerationStructureDeviceAddressInfoKHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR:
            dump_VkAccelerationStructureVersionInfoKHR<Format>(*reinterpret_cast<const VkAccelerationStructureVersionInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureVersionInfoKHR*" : "VkAccelerationStructureVersionInfoKHR"), "pNext", indents, reinterpret_cast<const VkAccelerationStructureVersionInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR:
            dump_VkCopyAccelerationStructureToMemoryInfoKHR<Format>(*reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyAccelerationStructureToMemoryInfoKHR*" : "VkCopyAccelerationStructureToMemoryInfoKHR"), "pNext", indents, reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR:
            dump_VkCopyMemoryToAccelerationStructureInfoKHR<Format>(*reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMemoryToAccelerationStructureInfoKHR*" : "VkCopyMemoryToAccelerationStructureInfoKHR"), "pNext", indents, reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR:
            dump_VkCopyAccelerationStructureInfoKHR<Format>(*reinterpret_cast<const VkCopyAccelerationStructureInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyAccelerationStructureInfoKHR*" : "VkCopyAccelerationStructureInfoKHR"), "pNext", indents, reinterpret_cast<const VkCopyAccelerationStructureInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR:
            dump_VkRayTracingShaderGroupCreateInfoKHR<Format>(*reinterpret_cast<const VkRayTracingShaderGroupCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingShaderGroupCreateInfoKHR*" : "VkRayTracingShaderGroupCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkRayTracingShaderGroupCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR:
            dump_VkRayTracingPipelineInterfaceCreateInfoKHR<Format>(*reinterpret_cast<const VkRayTracingPipelineInterfaceCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingPipelineInterfaceCreateInfoKHR*" : "VkRayTracingPipelineInterfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkRayTracingPipelineInterfaceCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
            dump_VkRayTracingPipelineCreateInfoKHR<Format>(*reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingPipelineCreateInfoKHR*" : "VkRayTracingPipelineCreateInfoKHR"), "pNext", indents, reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
            dump_VkPhysicalDeviceRayTracingPipelineFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingPipelineFeaturesKHR*" : "VkPhysicalDeviceRayTracingPipelineFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
            dump_VkPhysicalDeviceRayTracingPipelinePropertiesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingPipelinePropertiesKHR*" : "VkPhysicalDeviceRayTracingPipelinePropertiesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
            dump_VkPhysicalDeviceRayQueryFeaturesKHR<Format>(*reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayQueryFeaturesKHR*" : "VkPhysicalDeviceRayQueryFeaturesKHR"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
            dump_VkPhysicalDeviceMeshShaderFeaturesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMeshShaderFeaturesEXT*" : "VkPhysicalDeviceMeshShaderFeaturesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
            dump_VkPhysicalDeviceMeshShaderPropertiesEXT<Format>(*reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT*>(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMeshShaderPropertiesEXT*" : "VkPhysicalDeviceMeshShaderPropertiesEXT"), "pNext", indents, reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT*>(object));
            break;

        case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:  // 47
        case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:    // 48
            if (base_struct.pNext != nullptr) {
                dump_pNext_trampoline<Format>(reinterpret_cast<const void*>(base_struct.pNext), settings, type_name, var_name, indents);
            } else {
                dump_nullptr<Format>(settings, "const void*", "pNext", indents);
            }
            break;
        default:
            dump_start<Format>(settings, OutputConstruct::value, "const void*", "pNext", indents);
            dump_value<Format>(settings, "UNKNOWN (", (int64_t)(base_struct.sType), ")");
            dump_end<Format>(settings, OutputConstruct::value, indents);
    }
}

//========================== Function Helpers ===============================//

template <ApiDumpFormat Format>
void dump_params_vkCreateInstance(ApiDumpInstance& dump_inst, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkInstanceCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkInstanceCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInstance, settings, "VkInstance*", "pInstance", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkInstance<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyInstance(ApiDumpInstance& dump_inst, VkInstance instance, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkEnumeratePhysicalDevices(ApiDumpInstance& dump_inst, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPhysicalDeviceCount, settings, "uint32_t*", "pPhysicalDeviceCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPhysicalDevices, *pPhysicalDeviceCount, settings, "VkPhysicalDevice*", "pPhysicalDevices", "VkPhysicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDevice<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceFeatures(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFeatures, settings, "VkPhysicalDeviceFeatures*", "pFeatures", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFeatures<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceFormatProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFormat<Format>(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFormatProperties, settings, "VkFormatProperties*", "pFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFormatProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceImageFormatProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFormat<Format>(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageType<Format>(type, settings, "VkImageType", "type", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageTiling<Format>(tiling, settings, "VkImageTiling", "tiling", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageUsageFlags<Format>(usage, settings, "VkImageUsageFlags", "usage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageCreateFlags<Format>(flags, settings, "VkImageCreateFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImageFormatProperties, settings, "VkImageFormatProperties*", "pImageFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageFormatProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pProperties, settings, "VkPhysicalDeviceProperties*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceQueueFamilyProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueueFamilyPropertyCount, settings, "uint32_t*", "pQueueFamilyPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pQueueFamilyProperties, *pQueueFamilyPropertyCount, settings, "VkQueueFamilyProperties*", "pQueueFamilyProperties", "VkQueueFamilyProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceMemoryProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryProperties, settings, "VkPhysicalDeviceMemoryProperties*", "pMemoryProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceMemoryProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDevice(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDeviceCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDevice, settings, "VkDevice*", "pDevice", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDevice<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyDevice(ApiDumpInstance& dump_inst, VkDevice device, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkEnumerateInstanceExtensionProperties(ApiDumpInstance& dump_inst, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_char<Format>(pLayerName, settings, "const char*", "pLayerName", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkExtensionProperties*", "pProperties", "VkExtensionProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtensionProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkEnumerateDeviceExtensionProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_char<Format>(pLayerName, settings, "const char*", "pLayerName", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkExtensionProperties*", "pProperties", "VkExtensionProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtensionProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkEnumerateInstanceLayerProperties(ApiDumpInstance& dump_inst, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkLayerProperties*", "pProperties", "VkLayerProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkLayerProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkEnumerateDeviceLayerProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkLayerProperties*", "pProperties", "VkLayerProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkLayerProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceQueue(ApiDumpInstance& dump_inst, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueIndex, settings, "uint32_t", "queueIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueue, settings, "VkQueue*", "pQueue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueue<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueSubmit(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(submitCount, settings, "uint32_t", "submitCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSubmits, submitCount, settings, "const VkSubmitInfo*", "pSubmits", "const VkSubmitInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubmitInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_VkFence<Format>(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueWaitIdle(ApiDumpInstance& dump_inst, VkQueue queue) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDeviceWaitIdle(ApiDumpInstance& dump_inst, VkDevice device) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkAllocateMemory(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocateInfo, settings, "const VkMemoryAllocateInfo*", "pAllocateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryAllocateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemory, settings, "VkDeviceMemory*", "pMemory", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceMemory<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkFreeMemory(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeviceMemory<Format>(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkMapMemory(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeviceMemory<Format>(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(size, settings, "VkDeviceSize", "size", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkMemoryMapFlags<Format>(flags, settings, "VkMemoryMapFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, void**>(ppData, settings, "void**", "ppData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkUnmapMemory(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeviceMemory<Format>(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkFlushMappedMemoryRanges(ApiDumpInstance& dump_inst, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(memoryRangeCount, settings, "uint32_t", "memoryRangeCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pMemoryRanges, memoryRangeCount, settings, "const VkMappedMemoryRange*", "pMemoryRanges", "const VkMappedMemoryRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMappedMemoryRange<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkInvalidateMappedMemoryRanges(ApiDumpInstance& dump_inst, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(memoryRangeCount, settings, "uint32_t", "memoryRangeCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pMemoryRanges, memoryRangeCount, settings, "const VkMappedMemoryRange*", "pMemoryRanges", "const VkMappedMemoryRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMappedMemoryRange<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceMemoryCommitment(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeviceMemory<Format>(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCommittedMemoryInBytes, settings, "VkDeviceSize*", "pCommittedMemoryInBytes", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, VkDeviceSize>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBindBufferMemory(ApiDumpInstance& dump_inst, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeviceMemory<Format>(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(memoryOffset, settings, "VkDeviceSize", "memoryOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBindImageMemory(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeviceMemory<Format>(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(memoryOffset, settings, "VkDeviceSize", "memoryOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetBufferMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageSparseMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSparseImageFormatProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFormat<Format>(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageType<Format>(type, settings, "VkImageType", "type", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSampleCountFlagBits<Format>(samples, settings, "VkSampleCountFlagBits", "samples", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageUsageFlags<Format>(usage, settings, "VkImageUsageFlags", "usage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageTiling<Format>(tiling, settings, "VkImageTiling", "tiling", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkSparseImageFormatProperties*", "pProperties", "VkSparseImageFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageFormatProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueBindSparse(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindInfo, bindInfoCount, settings, "const VkBindSparseInfo*", "pBindInfo", "const VkBindSparseInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindSparseInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_VkFence<Format>(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateFence(ApiDumpInstance& dump_inst, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkFenceCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFenceCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFence, settings, "VkFence*", "pFence", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFence<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyFence(ApiDumpInstance& dump_inst, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFence<Format>(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkResetFences(ApiDumpInstance& dump_inst, VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(fenceCount, settings, "uint32_t", "fenceCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pFences, fenceCount, settings, "const VkFence*", "pFences", "const VkFence", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFence<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetFenceStatus(ApiDumpInstance& dump_inst, VkDevice device, VkFence fence) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFence<Format>(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkWaitForFences(ApiDumpInstance& dump_inst, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(fenceCount, settings, "uint32_t", "fenceCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pFences, fenceCount, settings, "const VkFence*", "pFences", "const VkFence", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFence<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(waitAll, settings, "VkBool32", "waitAll", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(timeout, settings, "uint64_t", "timeout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateSemaphore(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkSemaphoreCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSemaphore, settings, "VkSemaphore*", "pSemaphore", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphore<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroySemaphore(ApiDumpInstance& dump_inst, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSemaphore<Format>(semaphore, settings, "VkSemaphore", "semaphore", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateQueryPool(ApiDumpInstance& dump_inst, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkQueryPoolCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueryPoolCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueryPool, settings, "VkQueryPool*", "pQueryPool", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueryPool<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyQueryPool(ApiDumpInstance& dump_inst, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetQueryPoolResults(ApiDumpInstance& dump_inst, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queryCount, settings, "uint32_t", "queryCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, size_t>(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(stride, settings, "VkDeviceSize", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryResultFlags<Format>(flags, settings, "VkQueryResultFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateBuffer(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkBufferCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBuffer, settings, "VkBuffer*", "pBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyBuffer(ApiDumpInstance& dump_inst, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateImage(ApiDumpInstance& dump_inst, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkImageCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImage, settings, "VkImage*", "pImage", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImage<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyImage(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageSubresourceLayout(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubresource, settings, "const VkImageSubresource*", "pSubresource", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLayout, settings, "VkSubresourceLayout*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateImageView(ApiDumpInstance& dump_inst, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkImageViewCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pView, settings, "VkImageView*", "pView", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageView<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyImageView(ApiDumpInstance& dump_inst, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageView<Format>(imageView, settings, "VkImageView", "imageView", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateCommandPool(ApiDumpInstance& dump_inst, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkCommandPoolCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandPoolCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCommandPool, settings, "VkCommandPool*", "pCommandPool", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandPool<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyCommandPool(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCommandPool<Format>(commandPool, settings, "VkCommandPool", "commandPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkResetCommandPool(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCommandPool<Format>(commandPool, settings, "VkCommandPool", "commandPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCommandPoolResetFlags<Format>(flags, settings, "VkCommandPoolResetFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkAllocateCommandBuffers(ApiDumpInstance& dump_inst, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocateInfo, settings, "const VkCommandBufferAllocateInfo*", "pAllocateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBufferAllocateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCommandBuffers, pAllocateInfo->commandBufferCount, settings, "VkCommandBuffer*", "pCommandBuffers", "VkCommandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBuffer<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkFreeCommandBuffers(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCommandPool<Format>(commandPool, settings, "VkCommandPool", "commandPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(commandBufferCount, settings, "uint32_t", "commandBufferCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCommandBuffers, commandBufferCount, settings, "const VkCommandBuffer*", "pCommandBuffers", "const VkCommandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBuffer<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBeginCommandBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        ApiDumpInstance::current().setCmdBuffer(commandBuffer);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBeginInfo, settings, "const VkCommandBufferBeginInfo*", "pBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBufferBeginInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkEndCommandBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkResetCommandBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCommandBufferResetFlags<Format>(flags, settings, "VkCommandBufferResetFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(srcBuffer, settings, "VkBuffer", "srcBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pRegions, regionCount, settings, "const VkBufferCopy*", "pRegions", "const VkBufferCopy", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCopy<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(srcImage, settings, "VkImage", "srcImage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(dstImage, settings, "VkImage", "dstImage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pRegions, regionCount, settings, "const VkImageCopy*", "pRegions", "const VkImageCopy", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageCopy<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyBufferToImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(srcBuffer, settings, "VkBuffer", "srcBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(dstImage, settings, "VkImage", "dstImage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pRegions, regionCount, settings, "const VkBufferImageCopy*", "pRegions", "const VkBufferImageCopy", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferImageCopy<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyImageToBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(srcImage, settings, "VkImage", "srcImage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pRegions, regionCount, settings, "const VkBufferImageCopy*", "pRegions", "const VkBufferImageCopy", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferImageCopy<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdUpdateBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(dstOffset, settings, "VkDeviceSize", "dstOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(dataSize, settings, "VkDeviceSize", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const void*>(pData, settings, "const void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdFillBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(dstOffset, settings, "VkDeviceSize", "dstOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(size, settings, "VkDeviceSize", "size", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(data, settings, "uint32_t", "data", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPipelineBarrier(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlags<Format>(srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlags<Format>(dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDependencyFlags<Format>(dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(memoryBarrierCount, settings, "uint32_t", "memoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pMemoryBarriers, memoryBarrierCount, settings, "const VkMemoryBarrier*", "pMemoryBarriers", "const VkMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryBarrier<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bufferMemoryBarrierCount, settings, "uint32_t", "bufferMemoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBufferMemoryBarriers, bufferMemoryBarrierCount, settings, "const VkBufferMemoryBarrier*", "pBufferMemoryBarriers", "const VkBufferMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryBarrier<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(imageMemoryBarrierCount, settings, "uint32_t", "imageMemoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pImageMemoryBarriers, imageMemoryBarrierCount, settings, "const VkImageMemoryBarrier*", "pImageMemoryBarriers", "const VkImageMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryBarrier<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginQuery(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryControlFlags<Format>(flags, settings, "VkQueryControlFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndQuery(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdResetQueryPool(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queryCount, settings, "uint32_t", "queryCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWriteTimestamp(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlagBits<Format>(pipelineStage, settings, "VkPipelineStageFlagBits", "pipelineStage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyQueryPoolResults(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queryCount, settings, "uint32_t", "queryCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(dstOffset, settings, "VkDeviceSize", "dstOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(stride, settings, "VkDeviceSize", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryResultFlags<Format>(flags, settings, "VkQueryResultFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdExecuteCommands(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(commandBufferCount, settings, "uint32_t", "commandBufferCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCommandBuffers, commandBufferCount, settings, "const VkCommandBuffer*", "pCommandBuffers", "const VkCommandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBuffer<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateEvent(ApiDumpInstance& dump_inst, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkEventCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkEventCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pEvent, settings, "VkEvent*", "pEvent", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyEvent(ApiDumpInstance& dump_inst, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkEvent<Format>(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetEventStatus(ApiDumpInstance& dump_inst, VkDevice device, VkEvent event) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkEvent<Format>(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetEvent(ApiDumpInstance& dump_inst, VkDevice device, VkEvent event) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkEvent<Format>(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkResetEvent(ApiDumpInstance& dump_inst, VkDevice device, VkEvent event) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkEvent<Format>(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateBufferView(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkBufferViewCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferViewCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pView, settings, "VkBufferView*", "pView", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferView<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyBufferView(ApiDumpInstance& dump_inst, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBufferView<Format>(bufferView, settings, "VkBufferView", "bufferView", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateShaderModule(ApiDumpInstance& dump_inst, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkShaderModuleCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pShaderModule, settings, "VkShaderModule*", "pShaderModule", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModule<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyShaderModule(ApiDumpInstance& dump_inst, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderModule<Format>(shaderModule, settings, "VkShaderModule", "shaderModule", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreatePipelineCache(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkPipelineCacheCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCacheCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPipelineCache, settings, "VkPipelineCache*", "pPipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCache<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyPipelineCache(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineCache<Format>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPipelineCacheData(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineCache<Format>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDataSize, settings, "size_t*", "pDataSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, size_t>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkMergePipelineCaches(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineCache<Format>(dstCache, settings, "VkPipelineCache", "dstCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(srcCacheCount, settings, "uint32_t", "srcCacheCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSrcCaches, srcCacheCount, settings, "const VkPipelineCache*", "pSrcCaches", "const VkPipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCache<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateComputePipelines(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineCache<Format>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCreateInfos, createInfoCount, settings, "const VkComputePipelineCreateInfo*", "pCreateInfos", "const VkComputePipelineCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkComputePipelineCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyPipeline(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreatePipelineLayout(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkPipelineLayoutCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineLayoutCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPipelineLayout, settings, "VkPipelineLayout*", "pPipelineLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineLayout<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyPipelineLayout(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineLayout<Format>(pipelineLayout, settings, "VkPipelineLayout", "pipelineLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateSampler(ApiDumpInstance& dump_inst, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkSamplerCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSampler, settings, "VkSampler*", "pSampler", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSampler<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroySampler(ApiDumpInstance& dump_inst, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSampler<Format>(sampler, settings, "VkSampler", "sampler", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDescriptorSetLayout(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSetLayout, settings, "VkDescriptorSetLayout*", "pSetLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayout<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyDescriptorSetLayout(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorSetLayout<Format>(descriptorSetLayout, settings, "VkDescriptorSetLayout", "descriptorSetLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDescriptorPool(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDescriptorPoolCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorPoolCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDescriptorPool, settings, "VkDescriptorPool*", "pDescriptorPool", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorPool<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyDescriptorPool(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorPool<Format>(descriptorPool, settings, "VkDescriptorPool", "descriptorPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkResetDescriptorPool(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorPool<Format>(descriptorPool, settings, "VkDescriptorPool", "descriptorPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorPoolResetFlags<Format>(flags, settings, "VkDescriptorPoolResetFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkAllocateDescriptorSets(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocateInfo, settings, "const VkDescriptorSetAllocateInfo*", "pAllocateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetAllocateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDescriptorSets, pAllocateInfo->descriptorSetCount, settings, "VkDescriptorSet*", "pDescriptorSets", "VkDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSet<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkFreeDescriptorSets(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorPool<Format>(descriptorPool, settings, "VkDescriptorPool", "descriptorPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(descriptorSetCount, settings, "uint32_t", "descriptorSetCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDescriptorSets, descriptorSetCount, settings, "const VkDescriptorSet*", "pDescriptorSets", "const VkDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSet<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkUpdateDescriptorSets(ApiDumpInstance& dump_inst, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDescriptorWrites, descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteDescriptorSet<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(descriptorCopyCount, settings, "uint32_t", "descriptorCopyCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDescriptorCopies, descriptorCopyCount, settings, "const VkCopyDescriptorSet*", "pDescriptorCopies", "const VkCopyDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyDescriptorSet<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindPipeline(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineBindPoint<Format>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindDescriptorSets(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineBindPoint<Format>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineLayout<Format>(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstSet, settings, "uint32_t", "firstSet", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(descriptorSetCount, settings, "uint32_t", "descriptorSetCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDescriptorSets, descriptorSetCount, settings, "const VkDescriptorSet*", "pDescriptorSets", "const VkDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSet<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(dynamicOffsetCount, settings, "uint32_t", "dynamicOffsetCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDynamicOffsets, dynamicOffsetCount, settings, "const uint32_t*", "pDynamicOffsets", "const uint32_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const uint32_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdClearColorImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(imageLayout, settings, "VkImageLayout", "imageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pColor, settings, "const VkClearColorValue*", "pColor", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClearColorValue<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(rangeCount, settings, "uint32_t", "rangeCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pRanges, rangeCount, settings, "const VkImageSubresourceRange*", "pRanges", "const VkImageSubresourceRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresourceRange<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDispatch(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountX, settings, "uint32_t", "groupCountX", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountY, settings, "uint32_t", "groupCountY", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountZ, settings, "uint32_t", "groupCountZ", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDispatchIndirect(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetEvent(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkEvent<Format>(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlags<Format>(stageMask, settings, "VkPipelineStageFlags", "stageMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdResetEvent(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkEvent<Format>(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlags<Format>(stageMask, settings, "VkPipelineStageFlags", "stageMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWaitEvents(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(eventCount, settings, "uint32_t", "eventCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pEvents, eventCount, settings, "const VkEvent*", "pEvents", "const VkEvent", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent<Format>);
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlags<Format>(srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlags<Format>(dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(memoryBarrierCount, settings, "uint32_t", "memoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pMemoryBarriers, memoryBarrierCount, settings, "const VkMemoryBarrier*", "pMemoryBarriers", "const VkMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryBarrier<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bufferMemoryBarrierCount, settings, "uint32_t", "bufferMemoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBufferMemoryBarriers, bufferMemoryBarrierCount, settings, "const VkBufferMemoryBarrier*", "pBufferMemoryBarriers", "const VkBufferMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryBarrier<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(imageMemoryBarrierCount, settings, "uint32_t", "imageMemoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pImageMemoryBarriers, imageMemoryBarrierCount, settings, "const VkImageMemoryBarrier*", "pImageMemoryBarriers", "const VkImageMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryBarrier<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushConstants(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineLayout<Format>(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderStageFlags<Format>(stageFlags, settings, "VkShaderStageFlags", "stageFlags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(offset, settings, "uint32_t", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(size, settings, "uint32_t", "size", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const void*>(pValues, settings, "const void*", "pValues", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateGraphicsPipelines(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineCache<Format>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCreateInfos, createInfoCount, settings, "const VkGraphicsPipelineCreateInfo*", "pCreateInfos", "const VkGraphicsPipelineCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGraphicsPipelineCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateFramebuffer(ApiDumpInstance& dump_inst, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkFramebufferCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFramebufferCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFramebuffer, settings, "VkFramebuffer*", "pFramebuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFramebuffer<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyFramebuffer(ApiDumpInstance& dump_inst, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFramebuffer<Format>(framebuffer, settings, "VkFramebuffer", "framebuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateRenderPass(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkRenderPassCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderPass, settings, "VkRenderPass*", "pRenderPass", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPass<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyRenderPass(ApiDumpInstance& dump_inst, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkRenderPass<Format>(renderPass, settings, "VkRenderPass", "renderPass", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetRenderAreaGranularity(ApiDumpInstance& dump_inst, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkRenderPass<Format>(renderPass, settings, "VkRenderPass", "renderPass", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGranularity, settings, "VkExtent2D*", "pGranularity", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetViewport(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstViewport, settings, "uint32_t", "firstViewport", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pViewports, viewportCount, settings, "const VkViewport*", "pViewports", "const VkViewport", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViewport<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetScissor(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstScissor, settings, "uint32_t", "firstScissor", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(scissorCount, settings, "uint32_t", "scissorCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pScissors, scissorCount, settings, "const VkRect2D*", "pScissors", "const VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetLineWidth(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float lineWidth) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, float>(lineWidth, settings, "float", "lineWidth", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthBias(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, float>(depthBiasConstantFactor, settings, "float", "depthBiasConstantFactor", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, float>(depthBiasClamp, settings, "float", "depthBiasClamp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, float>(depthBiasSlopeFactor, settings, "float", "depthBiasSlopeFactor", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetBlendConstants(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const float blendConstants[4]) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(blendConstants, 4, settings, "const float[4]", "blendConstants", "const float", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const float>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthBounds(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, float>(minDepthBounds, settings, "float", "minDepthBounds", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, float>(maxDepthBounds, settings, "float", "maxDepthBounds", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetStencilCompareMask(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkStencilFaceFlags<Format>(faceMask, settings, "VkStencilFaceFlags", "faceMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(compareMask, settings, "uint32_t", "compareMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetStencilWriteMask(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkStencilFaceFlags<Format>(faceMask, settings, "VkStencilFaceFlags", "faceMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(writeMask, settings, "uint32_t", "writeMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetStencilReference(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkStencilFaceFlags<Format>(faceMask, settings, "VkStencilFaceFlags", "faceMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(reference, settings, "uint32_t", "reference", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindIndexBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkIndexType<Format>(indexType, settings, "VkIndexType", "indexType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindVertexBuffers(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstBinding, settings, "uint32_t", "firstBinding", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindingCount, settings, "uint32_t", "bindingCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBuffers, bindingCount, settings, "const VkBuffer*", "pBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pOffsets, bindingCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDraw(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(vertexCount, settings, "uint32_t", "vertexCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(instanceCount, settings, "uint32_t", "instanceCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstVertex, settings, "uint32_t", "firstVertex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstInstance, settings, "uint32_t", "firstInstance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndexed(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(indexCount, settings, "uint32_t", "indexCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(instanceCount, settings, "uint32_t", "instanceCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstIndex, settings, "uint32_t", "firstIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, int32_t>(vertexOffset, settings, "int32_t", "vertexOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstInstance, settings, "uint32_t", "firstInstance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndirect(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndexedIndirect(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBlitImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(srcImage, settings, "VkImage", "srcImage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(dstImage, settings, "VkImage", "dstImage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pRegions, regionCount, settings, "const VkImageBlit*", "pRegions", "const VkImageBlit", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageBlit<Format>);
        dump_separate_members<Format>(settings);
        dump_VkFilter<Format>(filter, settings, "VkFilter", "filter", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdClearDepthStencilImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(imageLayout, settings, "VkImageLayout", "imageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDepthStencil, settings, "const VkClearDepthStencilValue*", "pDepthStencil", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClearDepthStencilValue<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(rangeCount, settings, "uint32_t", "rangeCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pRanges, rangeCount, settings, "const VkImageSubresourceRange*", "pRanges", "const VkImageSubresourceRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresourceRange<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdClearAttachments(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pAttachments, attachmentCount, settings, "const VkClearAttachment*", "pAttachments", "const VkClearAttachment", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClearAttachment<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(rectCount, settings, "uint32_t", "rectCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pRects, rectCount, settings, "const VkClearRect*", "pRects", "const VkClearRect", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClearRect<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdResolveImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(srcImage, settings, "VkImage", "srcImage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(dstImage, settings, "VkImage", "dstImage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pRegions, regionCount, settings, "const VkImageResolve*", "pRegions", "const VkImageResolve", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageResolve<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginRenderPass(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderPassBegin, settings, "const VkRenderPassBeginInfo*", "pRenderPassBegin", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassBeginInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_VkSubpassContents<Format>(contents, settings, "VkSubpassContents", "contents", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdNextSubpass(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkSubpassContents contents) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSubpassContents<Format>(contents, settings, "VkSubpassContents", "contents", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndRenderPass(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBindBufferMemory2(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindInfos, bindInfoCount, settings, "const VkBindBufferMemoryInfo*", "pBindInfos", "const VkBindBufferMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindBufferMemoryInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBindImageMemory2(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindInfos, bindInfoCount, settings, "const VkBindImageMemoryInfo*", "pBindInfos", "const VkBindImageMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindImageMemoryInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceGroupPeerMemoryFeatures(ApiDumpInstance& dump_inst, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(heapIndex, settings, "uint32_t", "heapIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(localDeviceIndex, settings, "uint32_t", "localDeviceIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(remoteDeviceIndex, settings, "uint32_t", "remoteDeviceIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPeerMemoryFeatures, settings, "VkPeerMemoryFeatureFlags*", "pPeerMemoryFeatures", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPeerMemoryFeatureFlags<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDeviceMask(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t deviceMask) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(deviceMask, settings, "uint32_t", "deviceMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkEnumeratePhysicalDeviceGroups(ApiDumpInstance& dump_inst, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPhysicalDeviceGroupCount, settings, "uint32_t*", "pPhysicalDeviceGroupCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPhysicalDeviceGroupProperties, *pPhysicalDeviceGroupCount, settings, "VkPhysicalDeviceGroupProperties*", "pPhysicalDeviceGroupProperties", "VkPhysicalDeviceGroupProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceGroupProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageMemoryRequirements2(ApiDumpInstance& dump_inst, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkImageMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryRequirementsInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetBufferMemoryRequirements2(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkBufferMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryRequirementsInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageSparseMemoryRequirements2(ApiDumpInstance& dump_inst, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkImageSparseMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSparseMemoryRequirementsInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceFeatures2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFeatures, settings, "VkPhysicalDeviceFeatures2*", "pFeatures", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFeatures2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pProperties, settings, "VkPhysicalDeviceProperties2*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceFormatProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFormat<Format>(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFormatProperties, settings, "VkFormatProperties2*", "pFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFormatProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceImageFormatProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImageFormatInfo, settings, "const VkPhysicalDeviceImageFormatInfo2*", "pImageFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceImageFormatInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImageFormatProperties, settings, "VkImageFormatProperties2*", "pImageFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageFormatProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceQueueFamilyProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueueFamilyPropertyCount, settings, "uint32_t*", "pQueueFamilyPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pQueueFamilyProperties, *pQueueFamilyPropertyCount, settings, "VkQueueFamilyProperties2*", "pQueueFamilyProperties", "VkQueueFamilyProperties2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceMemoryProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryProperties, settings, "VkPhysicalDeviceMemoryProperties2*", "pMemoryProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceMemoryProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFormatInfo, settings, "const VkPhysicalDeviceSparseImageFormatInfo2*", "pFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSparseImageFormatInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkSparseImageFormatProperties2*", "pProperties", "VkSparseImageFormatProperties2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageFormatProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkTrimCommandPool(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCommandPool<Format>(commandPool, settings, "VkCommandPool", "commandPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCommandPoolTrimFlags<Format>(flags, settings, "VkCommandPoolTrimFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceQueue2(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueueInfo, settings, "const VkDeviceQueueInfo2*", "pQueueInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceQueueInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueue, settings, "VkQueue*", "pQueue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueue<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceExternalBufferProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalBufferInfo, settings, "const VkPhysicalDeviceExternalBufferInfo*", "pExternalBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalBufferInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalBufferProperties, settings, "VkExternalBufferProperties*", "pExternalBufferProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalBufferProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceExternalFenceProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalFenceInfo, settings, "const VkPhysicalDeviceExternalFenceInfo*", "pExternalFenceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalFenceInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalFenceProperties, settings, "VkExternalFenceProperties*", "pExternalFenceProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalFenceProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceExternalSemaphoreProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalSemaphoreInfo, settings, "const VkPhysicalDeviceExternalSemaphoreInfo*", "pExternalSemaphoreInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalSemaphoreInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalSemaphoreProperties, settings, "VkExternalSemaphoreProperties*", "pExternalSemaphoreProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalSemaphoreProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDispatchBase(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(baseGroupX, settings, "uint32_t", "baseGroupX", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(baseGroupY, settings, "uint32_t", "baseGroupY", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(baseGroupZ, settings, "uint32_t", "baseGroupZ", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountX, settings, "uint32_t", "groupCountX", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountY, settings, "uint32_t", "groupCountY", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountZ, settings, "uint32_t", "groupCountZ", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDescriptorUpdateTemplate(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDescriptorUpdateTemplateCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplateCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDescriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate*", "pDescriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplate<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyDescriptorUpdateTemplate(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorUpdateTemplate<Format>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkUpdateDescriptorSetWithTemplate(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorSet<Format>(descriptorSet, settings, "VkDescriptorSet", "descriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorUpdateTemplate<Format>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const void*>(pData, settings, "const void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDescriptorSetLayoutSupport(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSupport, settings, "VkDescriptorSetLayoutSupport*", "pSupport", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutSupport<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateSamplerYcbcrConversion(ApiDumpInstance& dump_inst, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkSamplerYcbcrConversionCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversionCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pYcbcrConversion, settings, "VkSamplerYcbcrConversion*", "pYcbcrConversion", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversion<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroySamplerYcbcrConversion(ApiDumpInstance& dump_inst, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSamplerYcbcrConversion<Format>(ycbcrConversion, settings, "VkSamplerYcbcrConversion", "ycbcrConversion", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkResetQueryPool(ApiDumpInstance& dump_inst, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queryCount, settings, "uint32_t", "queryCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSemaphoreCounterValue(ApiDumpInstance& dump_inst, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSemaphore<Format>(semaphore, settings, "VkSemaphore", "semaphore", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pValue, settings, "uint64_t*", "pValue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint64_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkWaitSemaphores(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pWaitInfo, settings, "const VkSemaphoreWaitInfo*", "pWaitInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreWaitInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(timeout, settings, "uint64_t", "timeout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSignalSemaphore(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSignalInfo, settings, "const VkSemaphoreSignalInfo*", "pSignalInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreSignalInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetBufferDeviceAddress(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetBufferOpaqueCaptureAddress(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceMemoryOpaqueCaptureAddress(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDeviceMemoryOpaqueCaptureAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceMemoryOpaqueCaptureAddressInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndirectCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndexedIndirectCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateRenderPass2(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkRenderPassCreateInfo2*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassCreateInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderPass, settings, "VkRenderPass*", "pRenderPass", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPass<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginRenderPass2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderPassBegin, settings, "const VkRenderPassBeginInfo*", "pRenderPassBegin", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassBeginInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdNextSubpass2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndRenderPass2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceToolProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pToolCount, settings, "uint32_t*", "pToolCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pToolProperties, *pToolCount, settings, "VkPhysicalDeviceToolProperties*", "pToolProperties", "VkPhysicalDeviceToolProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceToolProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreatePrivateDataSlot(ApiDumpInstance& dump_inst, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkPrivateDataSlotCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlotCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPrivateDataSlot, settings, "VkPrivateDataSlot*", "pPrivateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlot<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyPrivateDataSlot(ApiDumpInstance& dump_inst, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPrivateDataSlot<Format>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetPrivateData(ApiDumpInstance& dump_inst, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkObjectType<Format>(objectType, settings, "VkObjectType", "objectType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_uint64_t_as_pointer<Format>(objectHandle, settings, "uint64_t", "objectHandle", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPrivateDataSlot<Format>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(data, settings, "uint64_t", "data", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPrivateData(ApiDumpInstance& dump_inst, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkObjectType<Format>(objectType, settings, "VkObjectType", "objectType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_uint64_t_as_pointer<Format>(objectHandle, settings, "uint64_t", "objectHandle", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPrivateDataSlot<Format>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pData, settings, "uint64_t*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint64_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPipelineBarrier2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWriteTimestamp2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlags2<Format>(stage, settings, "VkPipelineStageFlags2", "stage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueSubmit2(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(submitCount, settings, "uint32_t", "submitCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSubmits, submitCount, settings, "const VkSubmitInfo2*", "pSubmits", "const VkSubmitInfo2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubmitInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_VkFence<Format>(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyBuffer2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyBufferInfo, settings, "const VkCopyBufferInfo2*", "pCopyBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyImageInfo, settings, "const VkCopyImageInfo2*", "pCopyImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyBufferToImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyBufferToImageInfo, settings, "const VkCopyBufferToImageInfo2*", "pCopyBufferToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferToImageInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyImageToBuffer2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyImageToBufferInfo, settings, "const VkCopyImageToBufferInfo2*", "pCopyImageToBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToBufferInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceBufferMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDeviceBufferMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceBufferMemoryRequirements<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceImageMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceImageSparseMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetEvent2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkEvent<Format>(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdResetEvent2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkEvent<Format>(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlags2<Format>(stageMask, settings, "VkPipelineStageFlags2", "stageMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWaitEvents2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(eventCount, settings, "uint32_t", "eventCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pEvents, eventCount, settings, "const VkEvent*", "pEvents", "const VkEvent", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDependencyInfos, eventCount, settings, "const VkDependencyInfo*", "pDependencyInfos", "const VkDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBlitImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBlitImageInfo, settings, "const VkBlitImageInfo2*", "pBlitImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBlitImageInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdResolveImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pResolveImageInfo, settings, "const VkResolveImageInfo2*", "pResolveImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkResolveImageInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginRendering(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderingInfo, settings, "const VkRenderingInfo*", "pRenderingInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndRendering(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetCullMode(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCullModeFlags<Format>(cullMode, settings, "VkCullModeFlags", "cullMode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetFrontFace(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFrontFace<Format>(frontFace, settings, "VkFrontFace", "frontFace", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetPrimitiveTopology(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPrimitiveTopology<Format>(primitiveTopology, settings, "VkPrimitiveTopology", "primitiveTopology", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetViewportWithCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pViewports, viewportCount, settings, "const VkViewport*", "pViewports", "const VkViewport", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViewport<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetScissorWithCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(scissorCount, settings, "uint32_t", "scissorCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pScissors, scissorCount, settings, "const VkRect2D*", "pScissors", "const VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindVertexBuffers2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstBinding, settings, "uint32_t", "firstBinding", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindingCount, settings, "uint32_t", "bindingCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBuffers, bindingCount, settings, "const VkBuffer*", "pBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pOffsets, bindingCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSizes, bindingCount, settings, "const VkDeviceSize*", "pSizes", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pStrides, bindingCount, settings, "const VkDeviceSize*", "pStrides", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthTestEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(depthTestEnable, settings, "VkBool32", "depthTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthWriteEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(depthWriteEnable, settings, "VkBool32", "depthWriteEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthCompareOp(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCompareOp<Format>(depthCompareOp, settings, "VkCompareOp", "depthCompareOp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthBoundsTestEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(depthBoundsTestEnable, settings, "VkBool32", "depthBoundsTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetStencilTestEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(stencilTestEnable, settings, "VkBool32", "stencilTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetStencilOp(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkStencilFaceFlags<Format>(faceMask, settings, "VkStencilFaceFlags", "faceMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkStencilOp<Format>(failOp, settings, "VkStencilOp", "failOp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkStencilOp<Format>(passOp, settings, "VkStencilOp", "passOp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkStencilOp<Format>(depthFailOp, settings, "VkStencilOp", "depthFailOp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCompareOp<Format>(compareOp, settings, "VkCompareOp", "compareOp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetRasterizerDiscardEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(rasterizerDiscardEnable, settings, "VkBool32", "rasterizerDiscardEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthBiasEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(depthBiasEnable, settings, "VkBool32", "depthBiasEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetPrimitiveRestartEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(primitiveRestartEnable, settings, "VkBool32", "primitiveRestartEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkMapMemory2(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryMapInfo, settings, "const VkMemoryMapInfo*", "pMemoryMapInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryMapInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void**>(ppData, settings, "void**", "ppData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkUnmapMemory2(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryUnmapInfo, settings, "const VkMemoryUnmapInfo*", "pMemoryUnmapInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryUnmapInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceImageSubresourceLayout(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDeviceImageSubresourceInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageSubresourceInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLayout, settings, "VkSubresourceLayout2*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageSubresourceLayout2(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubresource, settings, "const VkImageSubresource2*", "pSubresource", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLayout, settings, "VkSubresourceLayout2*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyMemoryToImage(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyMemoryToImageInfo, settings, "const VkCopyMemoryToImageInfo*", "pCopyMemoryToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToImageInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyImageToMemory(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyImageToMemoryInfo, settings, "const VkCopyImageToMemoryInfo*", "pCopyImageToMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToMemoryInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyImageToImage(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyImageToImageInfo, settings, "const VkCopyImageToImageInfo*", "pCopyImageToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToImageInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkTransitionImageLayout(ApiDumpInstance& dump_inst, VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(transitionCount, settings, "uint32_t", "transitionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pTransitions, transitionCount, settings, "const VkHostImageLayoutTransitionInfo*", "pTransitions", "const VkHostImageLayoutTransitionInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostImageLayoutTransitionInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushDescriptorSet(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineBindPoint<Format>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineLayout<Format>(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(set, settings, "uint32_t", "set", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDescriptorWrites, descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteDescriptorSet<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushDescriptorSetWithTemplate(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorUpdateTemplate<Format>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineLayout<Format>(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(set, settings, "uint32_t", "set", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const void*>(pData, settings, "const void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindDescriptorSets2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBindDescriptorSetsInfo, settings, "const VkBindDescriptorSetsInfo*", "pBindDescriptorSetsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDescriptorSetsInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushConstants2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPushConstantsInfo, settings, "const VkPushConstantsInfo*", "pPushConstantsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushConstantsInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushDescriptorSet2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPushDescriptorSetInfo, settings, "const VkPushDescriptorSetInfo*", "pPushDescriptorSetInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushDescriptorSetWithTemplate2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPushDescriptorSetWithTemplateInfo, settings, "const VkPushDescriptorSetWithTemplateInfo*", "pPushDescriptorSetWithTemplateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetWithTemplateInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetLineStipple(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(lineStippleFactor, settings, "uint32_t", "lineStippleFactor", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint16_t>(lineStipplePattern, settings, "uint16_t", "lineStipplePattern", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindIndexBuffer2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(size, settings, "VkDeviceSize", "size", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkIndexType<Format>(indexType, settings, "VkIndexType", "indexType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetRenderingAreaGranularity(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderingAreaInfo, settings, "const VkRenderingAreaInfo*", "pRenderingAreaInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAreaInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGranularity, settings, "VkExtent2D*", "pGranularity", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetRenderingAttachmentLocations(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLocationInfo, settings, "const VkRenderingAttachmentLocationInfo*", "pLocationInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAttachmentLocationInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetRenderingInputAttachmentIndices(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInputAttachmentIndexInfo, settings, "const VkRenderingInputAttachmentIndexInfo*", "pInputAttachmentIndexInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInputAttachmentIndexInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroySurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSurfaceKHR<Format>(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSurfaceSupportKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSurfaceKHR<Format>(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSupported, settings, "VkBool32*", "pSupported", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, VkBool32>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSurfaceKHR<Format>(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurfaceCapabilities, settings, "VkSurfaceCapabilitiesKHR*", "pSurfaceCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCapabilitiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSurfaceFormatsKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSurfaceKHR<Format>(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurfaceFormatCount, settings, "uint32_t*", "pSurfaceFormatCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSurfaceFormats, *pSurfaceFormatCount, settings, "VkSurfaceFormatKHR*", "pSurfaceFormats", "VkSurfaceFormatKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceFormatKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSurfacePresentModesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSurfaceKHR<Format>(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPresentModeCount, settings, "uint32_t*", "pPresentModeCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPresentModes, *pPresentModeCount, settings, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentModeKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateSwapchainKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkSwapchainCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSwapchain, settings, "VkSwapchainKHR*", "pSwapchain", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroySwapchainKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSwapchainImagesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSwapchainImageCount, settings, "uint32_t*", "pSwapchainImageCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSwapchainImages, *pSwapchainImageCount, settings, "VkImage*", "pSwapchainImages", "VkImage", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImage<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkAcquireNextImageKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(timeout, settings, "uint64_t", "timeout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSemaphore<Format>(semaphore, settings, "VkSemaphore", "semaphore", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFence<Format>(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImageIndex, settings, "uint32_t*", "pImageIndex", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueuePresentKHR(ApiDumpInstance& dump_inst, VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPresentInfo, settings, "const VkPresentInfoKHR*", "pPresentInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceGroupPresentCapabilitiesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDeviceGroupPresentCapabilities, settings, "VkDeviceGroupPresentCapabilitiesKHR*", "pDeviceGroupPresentCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceGroupPresentCapabilitiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceGroupSurfacePresentModesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSurfaceKHR<Format>(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pModes, settings, "VkDeviceGroupPresentModeFlagsKHR*", "pModes", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceGroupPresentModeFlagsKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDevicePresentRectanglesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSurfaceKHR<Format>(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRectCount, settings, "uint32_t*", "pRectCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pRects, *pRectCount, settings, "VkRect2D*", "pRects", "VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkAcquireNextImage2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAcquireInfo, settings, "const VkAcquireNextImageInfoKHR*", "pAcquireInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAcquireNextImageInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImageIndex, settings, "uint32_t*", "pImageIndex", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceDisplayPropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkDisplayPropertiesKHR*", "pProperties", "VkDisplayPropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPropertiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkDisplayPlanePropertiesKHR*", "pProperties", "VkDisplayPlanePropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlanePropertiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDisplayPlaneSupportedDisplaysKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(planeIndex, settings, "uint32_t", "planeIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDisplayCount, settings, "uint32_t*", "pDisplayCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDisplays, *pDisplayCount, settings, "VkDisplayKHR*", "pDisplays", "VkDisplayKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDisplayModePropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDisplayKHR<Format>(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkDisplayModePropertiesKHR*", "pProperties", "VkDisplayModePropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModePropertiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDisplayModeKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDisplayKHR<Format>(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDisplayModeCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModeCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMode, settings, "VkDisplayModeKHR*", "pMode", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModeKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDisplayPlaneCapabilitiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDisplayModeKHR<Format>(mode, settings, "VkDisplayModeKHR", "mode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(planeIndex, settings, "uint32_t", "planeIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCapabilities, settings, "VkDisplayPlaneCapabilitiesKHR*", "pCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneCapabilitiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDisplayPlaneSurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDisplaySurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplaySurfaceCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateSharedSwapchainsKHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(swapchainCount, settings, "uint32_t", "swapchainCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCreateInfos, swapchainCount, settings, "const VkSwapchainCreateInfoKHR*", "pCreateInfos", "const VkSwapchainCreateInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSwapchains, swapchainCount, settings, "VkSwapchainKHR*", "pSwapchains", "VkSwapchainKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_XLIB_KHR)

template <ApiDumpFormat Format>
void dump_params_vkCreateXlibSurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkXlibSurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkXlibSurfaceCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceXlibPresentationSupportKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, Display*>(dpy, settings, "Display*", "dpy", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VisualID>(visualID, settings, "VisualID", "visualID", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)

template <ApiDumpFormat Format>
void dump_params_vkCreateXcbSurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkXcbSurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkXcbSurfaceCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceXcbPresentationSupportKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, xcb_connection_t*>(connection, settings, "xcb_connection_t*", "connection", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, xcb_visualid_t>(visual_id, settings, "xcb_visualid_t", "visual_id", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)

template <ApiDumpFormat Format>
void dump_params_vkCreateWaylandSurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkWaylandSurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWaylandSurfaceCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceWaylandPresentationSupportKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, struct wl_display*>(display, settings, "struct wl_display*", "display", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)

template <ApiDumpFormat Format>
void dump_params_vkCreateAndroidSurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkAndroidSurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAndroidSurfaceCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)

template <ApiDumpFormat Format>
void dump_params_vkCreateWin32SurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkWin32SurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWin32SurfaceCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceWin32PresentationSupportKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceVideoCapabilitiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pVideoProfile, settings, "const VkVideoProfileInfoKHR*", "pVideoProfile", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoProfileInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCapabilities, settings, "VkVideoCapabilitiesKHR*", "pCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoCapabilitiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceVideoFormatPropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pVideoFormatInfo, settings, "const VkPhysicalDeviceVideoFormatInfoKHR*", "pVideoFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceVideoFormatInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pVideoFormatPropertyCount, settings, "uint32_t*", "pVideoFormatPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pVideoFormatProperties, *pVideoFormatPropertyCount, settings, "VkVideoFormatPropertiesKHR*", "pVideoFormatProperties", "VkVideoFormatPropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoFormatPropertiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateVideoSessionKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkVideoSessionCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pVideoSession, settings, "VkVideoSessionKHR*", "pVideoSession", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyVideoSessionKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkVideoSessionKHR<Format>(videoSession, settings, "VkVideoSessionKHR", "videoSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetVideoSessionMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkVideoSessionKHR<Format>(videoSession, settings, "VkVideoSessionKHR", "videoSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirementsCount, settings, "uint32_t*", "pMemoryRequirementsCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pMemoryRequirements, *pMemoryRequirementsCount, settings, "VkVideoSessionMemoryRequirementsKHR*", "pMemoryRequirements", "VkVideoSessionMemoryRequirementsKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionMemoryRequirementsKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBindVideoSessionMemoryKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkVideoSessionKHR<Format>(videoSession, settings, "VkVideoSessionKHR", "videoSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindSessionMemoryInfoCount, settings, "uint32_t", "bindSessionMemoryInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindSessionMemoryInfos, bindSessionMemoryInfoCount, settings, "const VkBindVideoSessionMemoryInfoKHR*", "pBindSessionMemoryInfos", "const VkBindVideoSessionMemoryInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindVideoSessionMemoryInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkVideoSessionParametersCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionParametersCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pVideoSessionParameters, settings, "VkVideoSessionParametersKHR*", "pVideoSessionParameters", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionParametersKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkUpdateVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkVideoSessionParametersKHR<Format>(videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pUpdateInfo, settings, "const VkVideoSessionParametersUpdateInfoKHR*", "pUpdateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionParametersUpdateInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkVideoSessionParametersKHR<Format>(videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginVideoCodingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBeginInfo, settings, "const VkVideoBeginCodingInfoKHR*", "pBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoBeginCodingInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndVideoCodingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pEndCodingInfo, settings, "const VkVideoEndCodingInfoKHR*", "pEndCodingInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEndCodingInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdControlVideoCodingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCodingControlInfo, settings, "const VkVideoCodingControlInfoKHR*", "pCodingControlInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoCodingControlInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDecodeVideoKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDecodeInfo, settings, "const VkVideoDecodeInfoKHR*", "pDecodeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoDecodeInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginRenderingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderingInfo, settings, "const VkRenderingInfo*", "pRenderingInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndRenderingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceFeatures2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFeatures, settings, "VkPhysicalDeviceFeatures2*", "pFeatures", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFeatures2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pProperties, settings, "VkPhysicalDeviceProperties2*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceFormatProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFormat<Format>(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFormatProperties, settings, "VkFormatProperties2*", "pFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFormatProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceImageFormatProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImageFormatInfo, settings, "const VkPhysicalDeviceImageFormatInfo2*", "pImageFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceImageFormatInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImageFormatProperties, settings, "VkImageFormatProperties2*", "pImageFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageFormatProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceQueueFamilyProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueueFamilyPropertyCount, settings, "uint32_t*", "pQueueFamilyPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pQueueFamilyProperties, *pQueueFamilyPropertyCount, settings, "VkQueueFamilyProperties2*", "pQueueFamilyProperties", "VkQueueFamilyProperties2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceMemoryProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryProperties, settings, "VkPhysicalDeviceMemoryProperties2*", "pMemoryProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceMemoryProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFormatInfo, settings, "const VkPhysicalDeviceSparseImageFormatInfo2*", "pFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSparseImageFormatInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkSparseImageFormatProperties2*", "pProperties", "VkSparseImageFormatProperties2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageFormatProperties2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceGroupPeerMemoryFeaturesKHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(heapIndex, settings, "uint32_t", "heapIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(localDeviceIndex, settings, "uint32_t", "localDeviceIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(remoteDeviceIndex, settings, "uint32_t", "remoteDeviceIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPeerMemoryFeatures, settings, "VkPeerMemoryFeatureFlags*", "pPeerMemoryFeatures", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPeerMemoryFeatureFlags<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDeviceMaskKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t deviceMask) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(deviceMask, settings, "uint32_t", "deviceMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDispatchBaseKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(baseGroupX, settings, "uint32_t", "baseGroupX", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(baseGroupY, settings, "uint32_t", "baseGroupY", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(baseGroupZ, settings, "uint32_t", "baseGroupZ", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountX, settings, "uint32_t", "groupCountX", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountY, settings, "uint32_t", "groupCountY", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountZ, settings, "uint32_t", "groupCountZ", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkTrimCommandPoolKHR(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCommandPool<Format>(commandPool, settings, "VkCommandPool", "commandPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCommandPoolTrimFlags<Format>(flags, settings, "VkCommandPoolTrimFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkEnumeratePhysicalDeviceGroupsKHR(ApiDumpInstance& dump_inst, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPhysicalDeviceGroupCount, settings, "uint32_t*", "pPhysicalDeviceGroupCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPhysicalDeviceGroupProperties, *pPhysicalDeviceGroupCount, settings, "VkPhysicalDeviceGroupProperties*", "pPhysicalDeviceGroupProperties", "VkPhysicalDeviceGroupProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceGroupProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceExternalBufferPropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalBufferInfo, settings, "const VkPhysicalDeviceExternalBufferInfo*", "pExternalBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalBufferInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalBufferProperties, settings, "VkExternalBufferProperties*", "pExternalBufferProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalBufferProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryWin32HandleKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGetWin32HandleInfo, settings, "const VkMemoryGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetWin32HandleInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pHandle, settings, "HANDLE*", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, HANDLE>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryWin32HandlePropertiesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkExternalMemoryHandleTypeFlagBits<Format>(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, HANDLE>(handle, settings, "HANDLE", "handle", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryWin32HandleProperties, settings, "VkMemoryWin32HandlePropertiesKHR*", "pMemoryWin32HandleProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryWin32HandlePropertiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryFdKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGetFdInfo, settings, "const VkMemoryGetFdInfoKHR*", "pGetFdInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetFdInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFd, settings, "int*", "pFd", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, int>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryFdPropertiesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkExternalMemoryHandleTypeFlagBits<Format>(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, int>(fd, settings, "int", "fd", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryFdProperties, settings, "VkMemoryFdPropertiesKHR*", "pMemoryFdProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryFdPropertiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalSemaphoreInfo, settings, "const VkPhysicalDeviceExternalSemaphoreInfo*", "pExternalSemaphoreInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalSemaphoreInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalSemaphoreProperties, settings, "VkExternalSemaphoreProperties*", "pExternalSemaphoreProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalSemaphoreProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)

template <ApiDumpFormat Format>
void dump_params_vkImportSemaphoreWin32HandleKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImportSemaphoreWin32HandleInfo, settings, "const VkImportSemaphoreWin32HandleInfoKHR*", "pImportSemaphoreWin32HandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImportSemaphoreWin32HandleInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSemaphoreWin32HandleKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGetWin32HandleInfo, settings, "const VkSemaphoreGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreGetWin32HandleInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pHandle, settings, "HANDLE*", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, HANDLE>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

template <ApiDumpFormat Format>
void dump_params_vkImportSemaphoreFdKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImportSemaphoreFdInfo, settings, "const VkImportSemaphoreFdInfoKHR*", "pImportSemaphoreFdInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImportSemaphoreFdInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSemaphoreFdKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGetFdInfo, settings, "const VkSemaphoreGetFdInfoKHR*", "pGetFdInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreGetFdInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFd, settings, "int*", "pFd", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, int>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushDescriptorSetKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineBindPoint<Format>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineLayout<Format>(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(set, settings, "uint32_t", "set", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDescriptorWrites, descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteDescriptorSet<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushDescriptorSetWithTemplateKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorUpdateTemplate<Format>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineLayout<Format>(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(set, settings, "uint32_t", "set", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const void*>(pData, settings, "const void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDescriptorUpdateTemplateKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDescriptorUpdateTemplateCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplateCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDescriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate*", "pDescriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplate<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyDescriptorUpdateTemplateKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorUpdateTemplate<Format>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkUpdateDescriptorSetWithTemplateKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorSet<Format>(descriptorSet, settings, "VkDescriptorSet", "descriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorUpdateTemplate<Format>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const void*>(pData, settings, "const void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateRenderPass2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkRenderPassCreateInfo2*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassCreateInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderPass, settings, "VkRenderPass*", "pRenderPass", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPass<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginRenderPass2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderPassBegin, settings, "const VkRenderPassBeginInfo*", "pRenderPassBegin", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassBeginInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdNextSubpass2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndRenderPass2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSwapchainStatusKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceExternalFencePropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalFenceInfo, settings, "const VkPhysicalDeviceExternalFenceInfo*", "pExternalFenceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalFenceInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalFenceProperties, settings, "VkExternalFenceProperties*", "pExternalFenceProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalFenceProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)

template <ApiDumpFormat Format>
void dump_params_vkImportFenceWin32HandleKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImportFenceWin32HandleInfo, settings, "const VkImportFenceWin32HandleInfoKHR*", "pImportFenceWin32HandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImportFenceWin32HandleInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetFenceWin32HandleKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGetWin32HandleInfo, settings, "const VkFenceGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFenceGetWin32HandleInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pHandle, settings, "HANDLE*", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, HANDLE>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

template <ApiDumpFormat Format>
void dump_params_vkImportFenceFdKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImportFenceFdInfo, settings, "const VkImportFenceFdInfoKHR*", "pImportFenceFdInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImportFenceFdInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetFenceFdKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGetFdInfo, settings, "const VkFenceGetFdInfoKHR*", "pGetFdInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFenceGetFdInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFd, settings, "int*", "pFd", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, int>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCounterCount, settings, "uint32_t*", "pCounterCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCounters, *pCounterCount, settings, "VkPerformanceCounterKHR*", "pCounters", "VkPerformanceCounterKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCounterDescriptions, *pCounterCount, settings, "VkPerformanceCounterDescriptionKHR*", "pCounterDescriptions", "VkPerformanceCounterDescriptionKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterDescriptionKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPerformanceQueryCreateInfo, settings, "const VkQueryPoolPerformanceCreateInfoKHR*", "pPerformanceQueryCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueryPoolPerformanceCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pNumPasses, settings, "uint32_t*", "pNumPasses", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkAcquireProfilingLockKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkAcquireProfilingLockInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAcquireProfilingLockInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkReleaseProfilingLockKHR(ApiDumpInstance& dump_inst, VkDevice device) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSurfaceCapabilities2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurfaceCapabilities, settings, "VkSurfaceCapabilities2KHR*", "pSurfaceCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCapabilities2KHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSurfaceFormats2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurfaceFormatCount, settings, "uint32_t*", "pSurfaceFormatCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSurfaceFormats, *pSurfaceFormatCount, settings, "VkSurfaceFormat2KHR*", "pSurfaceFormats", "VkSurfaceFormat2KHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceFormat2KHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceDisplayProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkDisplayProperties2KHR*", "pProperties", "VkDisplayProperties2KHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayProperties2KHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkDisplayPlaneProperties2KHR*", "pProperties", "VkDisplayPlaneProperties2KHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneProperties2KHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDisplayModeProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDisplayKHR<Format>(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkDisplayModeProperties2KHR*", "pProperties", "VkDisplayModeProperties2KHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModeProperties2KHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDisplayPlaneCapabilities2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDisplayPlaneInfo, settings, "const VkDisplayPlaneInfo2KHR*", "pDisplayPlaneInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneInfo2KHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCapabilities, settings, "VkDisplayPlaneCapabilities2KHR*", "pCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneCapabilities2KHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageMemoryRequirements2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkImageMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryRequirementsInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetBufferMemoryRequirements2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkBufferMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryRequirementsInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageSparseMemoryRequirements2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkImageSparseMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSparseMemoryRequirementsInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateSamplerYcbcrConversionKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkSamplerYcbcrConversionCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversionCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pYcbcrConversion, settings, "VkSamplerYcbcrConversion*", "pYcbcrConversion", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversion<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroySamplerYcbcrConversionKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSamplerYcbcrConversion<Format>(ycbcrConversion, settings, "VkSamplerYcbcrConversion", "ycbcrConversion", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBindBufferMemory2KHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindInfos, bindInfoCount, settings, "const VkBindBufferMemoryInfo*", "pBindInfos", "const VkBindBufferMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindBufferMemoryInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBindImageMemory2KHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindInfos, bindInfoCount, settings, "const VkBindImageMemoryInfo*", "pBindInfos", "const VkBindImageMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindImageMemoryInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDescriptorSetLayoutSupportKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSupport, settings, "VkDescriptorSetLayoutSupport*", "pSupport", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutSupport<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndirectCountKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndexedIndirectCountKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSemaphoreCounterValueKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSemaphore<Format>(semaphore, settings, "VkSemaphore", "semaphore", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pValue, settings, "uint64_t*", "pValue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint64_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkWaitSemaphoresKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pWaitInfo, settings, "const VkSemaphoreWaitInfo*", "pWaitInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreWaitInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(timeout, settings, "uint64_t", "timeout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSignalSemaphoreKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSignalInfo, settings, "const VkSemaphoreSignalInfo*", "pSignalInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreSignalInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceFragmentShadingRatesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFragmentShadingRateCount, settings, "uint32_t*", "pFragmentShadingRateCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pFragmentShadingRates, *pFragmentShadingRateCount, settings, "VkPhysicalDeviceFragmentShadingRateKHR*", "pFragmentShadingRates", "VkPhysicalDeviceFragmentShadingRateKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFragmentShadingRateKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetFragmentShadingRateKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFragmentSize, settings, "const VkExtent2D*", "pFragmentSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(combinerOps, 2, settings, "const VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "const VkFragmentShadingRateCombinerOpKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFragmentShadingRateCombinerOpKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetRenderingAttachmentLocationsKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLocationInfo, settings, "const VkRenderingAttachmentLocationInfo*", "pLocationInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAttachmentLocationInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetRenderingInputAttachmentIndicesKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInputAttachmentIndexInfo, settings, "const VkRenderingInputAttachmentIndexInfo*", "pInputAttachmentIndexInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInputAttachmentIndexInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkWaitForPresentKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(presentId, settings, "uint64_t", "presentId", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(timeout, settings, "uint64_t", "timeout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetBufferDeviceAddressKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetBufferOpaqueCaptureAddressKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceMemoryOpaqueCaptureAddressKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDeviceMemoryOpaqueCaptureAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceMemoryOpaqueCaptureAddressInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDeferredOperationKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDeferredOperation, settings, "VkDeferredOperationKHR*", "pDeferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeferredOperationKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyDeferredOperationKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(operation, settings, "VkDeferredOperationKHR", "operation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeferredOperationMaxConcurrencyKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR operation) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(operation, settings, "VkDeferredOperationKHR", "operation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeferredOperationResultKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR operation) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(operation, settings, "VkDeferredOperationKHR", "operation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDeferredOperationJoinKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR operation) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(operation, settings, "VkDeferredOperationKHR", "operation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPipelineExecutablePropertiesKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPipelineInfo, settings, "const VkPipelineInfoKHR*", "pPipelineInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExecutableCount, settings, "uint32_t*", "pExecutableCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pExecutableCount, settings, "VkPipelineExecutablePropertiesKHR*", "pProperties", "VkPipelineExecutablePropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutablePropertiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPipelineExecutableStatisticsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExecutableInfo, settings, "const VkPipelineExecutableInfoKHR*", "pExecutableInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pStatisticCount, settings, "uint32_t*", "pStatisticCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pStatistics, *pStatisticCount, settings, "VkPipelineExecutableStatisticKHR*", "pStatistics", "VkPipelineExecutableStatisticKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableStatisticKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPipelineExecutableInternalRepresentationsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExecutableInfo, settings, "const VkPipelineExecutableInfoKHR*", "pExecutableInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInternalRepresentationCount, settings, "uint32_t*", "pInternalRepresentationCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pInternalRepresentations, *pInternalRepresentationCount, settings, "VkPipelineExecutableInternalRepresentationKHR*", "pInternalRepresentations", "VkPipelineExecutableInternalRepresentationKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableInternalRepresentationKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkMapMemory2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryMapInfo, settings, "const VkMemoryMapInfo*", "pMemoryMapInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryMapInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void**>(ppData, settings, "void**", "ppData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkUnmapMemory2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryUnmapInfo, settings, "const VkMemoryUnmapInfo*", "pMemoryUnmapInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryUnmapInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQualityLevelInfo, settings, "const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*", "pQualityLevelInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQualityLevelProperties, settings, "VkVideoEncodeQualityLevelPropertiesKHR*", "pQualityLevelProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeQualityLevelPropertiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetEncodedVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pVideoSessionParametersInfo, settings, "const VkVideoEncodeSessionParametersGetInfoKHR*", "pVideoSessionParametersInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeSessionParametersGetInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFeedbackInfo, settings, "VkVideoEncodeSessionParametersFeedbackInfoKHR*", "pFeedbackInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeSessionParametersFeedbackInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDataSize, settings, "size_t*", "pDataSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, size_t>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEncodeVideoKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pEncodeInfo, settings, "const VkVideoEncodeInfoKHR*", "pEncodeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetEvent2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkEvent<Format>(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdResetEvent2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkEvent<Format>(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlags2<Format>(stageMask, settings, "VkPipelineStageFlags2", "stageMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWaitEvents2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(eventCount, settings, "uint32_t", "eventCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pEvents, eventCount, settings, "const VkEvent*", "pEvents", "const VkEvent", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDependencyInfos, eventCount, settings, "const VkDependencyInfo*", "pDependencyInfos", "const VkDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPipelineBarrier2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWriteTimestamp2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlags2<Format>(stage, settings, "VkPipelineStageFlags2", "stage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueSubmit2KHR(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(submitCount, settings, "uint32_t", "submitCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSubmits, submitCount, settings, "const VkSubmitInfo2*", "pSubmits", "const VkSubmitInfo2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubmitInfo2<Format>);
        dump_separate_members<Format>(settings);
        dump_VkFence<Format>(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindIndexBuffer3KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindIndexBuffer3InfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkBindIndexBuffer3InfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindIndexBuffer3InfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindVertexBuffers3KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBindVertexBuffer3InfoKHR* pBindingInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstBinding, settings, "uint32_t", "firstBinding", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindingCount, settings, "uint32_t", "bindingCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindingInfos, bindingCount, settings, "const VkBindVertexBuffer3InfoKHR*", "pBindingInfos", "const VkBindVertexBuffer3InfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindVertexBuffer3InfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndirect2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDrawIndirect2InfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDrawIndirect2InfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndexedIndirect2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDrawIndirect2InfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDrawIndirect2InfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDispatchIndirect2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDispatchIndirect2InfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDispatchIndirect2InfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDispatchIndirect2InfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyMemoryKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyDeviceMemoryInfoKHR* pCopyMemoryInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyMemoryInfo, settings, "const VkCopyDeviceMemoryInfoKHR*", "pCopyMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyDeviceMemoryInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyMemoryToImageKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyMemoryInfo, settings, "const VkCopyDeviceMemoryImageInfoKHR*", "pCopyMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyDeviceMemoryImageInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyImageToMemoryKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyMemoryInfo, settings, "const VkCopyDeviceMemoryImageInfoKHR*", "pCopyMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyDeviceMemoryImageInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdUpdateMemoryKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange, VkAddressCommandFlagsKHR dstFlags, VkDeviceSize dataSize, const void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDstRange, settings, "const VkDeviceAddressRangeKHR*", "pDstRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceAddressRangeKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_VkAddressCommandFlagsKHR<Format>(dstFlags, settings, "VkAddressCommandFlagsKHR", "dstFlags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(dataSize, settings, "VkDeviceSize", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const void*>(pData, settings, "const void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdFillMemoryKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange, VkAddressCommandFlagsKHR dstFlags, uint32_t data) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDstRange, settings, "const VkDeviceAddressRangeKHR*", "pDstRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceAddressRangeKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_VkAddressCommandFlagsKHR<Format>(dstFlags, settings, "VkAddressCommandFlagsKHR", "dstFlags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(data, settings, "uint32_t", "data", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyQueryPoolResultsToMemoryKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, const VkStridedDeviceAddressRangeKHR* pDstRange, VkAddressCommandFlagsKHR dstFlags, VkQueryResultFlags queryResultFlags) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queryCount, settings, "uint32_t", "queryCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDstRange, settings, "const VkStridedDeviceAddressRangeKHR*", "pDstRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRangeKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_VkAddressCommandFlagsKHR<Format>(dstFlags, settings, "VkAddressCommandFlagsKHR", "dstFlags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryResultFlags<Format>(queryResultFlags, settings, "VkQueryResultFlags", "queryResultFlags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndirectCount2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDrawIndirectCount2InfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDrawIndirectCount2InfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDrawIndirectCount2InfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndexedIndirectCount2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDrawIndirectCount2InfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDrawIndirectCount2InfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDrawIndirectCount2InfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginConditionalRendering2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfo2EXT* pConditionalRenderingBegin) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pConditionalRenderingBegin, settings, "const VkConditionalRenderingBeginInfo2EXT*", "pConditionalRenderingBegin", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkConditionalRenderingBeginInfo2EXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindTransformFeedbackBuffers2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBindTransformFeedbackBuffer2InfoEXT* pBindingInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstBinding, settings, "uint32_t", "firstBinding", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindingCount, settings, "uint32_t", "bindingCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindingInfos, bindingCount, settings, "const VkBindTransformFeedbackBuffer2InfoEXT*", "pBindingInfos", "const VkBindTransformFeedbackBuffer2InfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindTransformFeedbackBuffer2InfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginTransformFeedback2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstCounterRange, uint32_t counterRangeCount, const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstCounterRange, settings, "uint32_t", "firstCounterRange", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(counterRangeCount, settings, "uint32_t", "counterRangeCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCounterInfos, counterRangeCount, settings, "const VkBindTransformFeedbackBuffer2InfoEXT*", "pCounterInfos", "const VkBindTransformFeedbackBuffer2InfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindTransformFeedbackBuffer2InfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndTransformFeedback2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstCounterRange, uint32_t counterRangeCount, const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstCounterRange, settings, "uint32_t", "firstCounterRange", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(counterRangeCount, settings, "uint32_t", "counterRangeCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCounterInfos, counterRangeCount, settings, "const VkBindTransformFeedbackBuffer2InfoEXT*", "pCounterInfos", "const VkBindTransformFeedbackBuffer2InfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindTransformFeedbackBuffer2InfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndirectByteCount2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfo, uint32_t counterOffset, uint32_t vertexStride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(instanceCount, settings, "uint32_t", "instanceCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstInstance, settings, "uint32_t", "firstInstance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCounterInfo, settings, "const VkBindTransformFeedbackBuffer2InfoEXT*", "pCounterInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindTransformFeedbackBuffer2InfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(counterOffset, settings, "uint32_t", "counterOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(vertexStride, settings, "uint32_t", "vertexStride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawMeshTasksIndirect2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDrawIndirect2InfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDrawIndirect2InfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawMeshTasksIndirectCount2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDrawIndirectCount2InfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDrawIndirectCount2InfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDrawIndirectCount2InfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWriteMarkerToMemoryAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkMemoryMarkerInfoAMD* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkMemoryMarkerInfoAMD*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryMarkerInfoAMD<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateAccelerationStructure2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkAccelerationStructureCreateInfo2KHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCreateInfo2KHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAccelerationStructure, settings, "VkAccelerationStructureKHR*", "pAccelerationStructure", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyBuffer2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyBufferInfo, settings, "const VkCopyBufferInfo2*", "pCopyBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyImageInfo, settings, "const VkCopyImageInfo2*", "pCopyImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyBufferToImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyBufferToImageInfo, settings, "const VkCopyBufferToImageInfo2*", "pCopyBufferToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferToImageInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyImageToBuffer2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyImageToBufferInfo, settings, "const VkCopyImageToBufferInfo2*", "pCopyImageToBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToBufferInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBlitImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBlitImageInfo, settings, "const VkBlitImageInfo2*", "pBlitImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBlitImageInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdResolveImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pResolveImageInfo, settings, "const VkResolveImageInfo2*", "pResolveImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkResolveImageInfo2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdTraceRaysIndirect2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(indirectDeviceAddress, settings, "VkDeviceAddress", "indirectDeviceAddress", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceBufferMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDeviceBufferMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceBufferMemoryRequirements<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceImageMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceImageSparseMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindIndexBuffer2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(size, settings, "VkDeviceSize", "size", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkIndexType<Format>(indexType, settings, "VkIndexType", "indexType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetRenderingAreaGranularityKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderingAreaInfo, settings, "const VkRenderingAreaInfo*", "pRenderingAreaInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAreaInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGranularity, settings, "VkExtent2D*", "pGranularity", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceImageSubresourceLayoutKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDeviceImageSubresourceInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageSubresourceInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLayout, settings, "VkSubresourceLayout2*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageSubresourceLayout2KHR(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubresource, settings, "const VkImageSubresource2*", "pSubresource", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLayout, settings, "VkSubresourceLayout2*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkWaitForPresent2KHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR* pPresentWait2Info) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPresentWait2Info, settings, "const VkPresentWait2InfoKHR*", "pPresentWait2Info", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentWait2InfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreatePipelineBinariesKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkPipelineBinaryCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBinaries, settings, "VkPipelineBinaryHandlesInfoKHR*", "pBinaries", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryHandlesInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyPipelineBinaryKHR(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineBinaryKHR<Format>(pipelineBinary, settings, "VkPipelineBinaryKHR", "pipelineBinary", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPipelineKeyKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPipelineCreateInfo, settings, "const VkPipelineCreateInfoKHR*", "pPipelineCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPipelineKey, settings, "VkPipelineBinaryKeyKHR*", "pPipelineKey", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryKeyKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPipelineBinaryDataKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkPipelineBinaryDataInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryDataInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPipelineBinaryKey, settings, "VkPipelineBinaryKeyKHR*", "pPipelineBinaryKey", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryKeyKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPipelineBinaryDataSize, settings, "size_t*", "pPipelineBinaryDataSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, size_t>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pPipelineBinaryData, settings, "void*", "pPipelineBinaryData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkReleaseCapturedPipelineDataKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkReleaseCapturedPipelineDataInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkReleaseCapturedPipelineDataInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkReleaseSwapchainImagesKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pReleaseInfo, settings, "const VkReleaseSwapchainImagesInfoKHR*", "pReleaseInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkReleaseSwapchainImagesInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkCooperativeMatrixPropertiesKHR*", "pProperties", "VkCooperativeMatrixPropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeMatrixPropertiesKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetLineStippleKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(lineStippleFactor, settings, "uint32_t", "lineStippleFactor", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint16_t>(lineStipplePattern, settings, "uint16_t", "lineStipplePattern", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pTimeDomainCount, settings, "uint32_t*", "pTimeDomainCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pTimeDomains, *pTimeDomainCount, settings, "VkTimeDomainKHR*", "pTimeDomains", "VkTimeDomainKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTimeDomainKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetCalibratedTimestampsKHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(timestampCount, settings, "uint32_t", "timestampCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pTimestampInfos, timestampCount, settings, "const VkCalibratedTimestampInfoKHR*", "pTimestampInfos", "const VkCalibratedTimestampInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCalibratedTimestampInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pTimestamps, timestampCount, settings, "uint64_t*", "pTimestamps", "uint64_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint64_t>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMaxDeviation, settings, "uint64_t*", "pMaxDeviation", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint64_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindDescriptorSets2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBindDescriptorSetsInfo, settings, "const VkBindDescriptorSetsInfo*", "pBindDescriptorSetsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDescriptorSetsInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushConstants2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPushConstantsInfo, settings, "const VkPushConstantsInfo*", "pPushConstantsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushConstantsInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushDescriptorSet2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPushDescriptorSetInfo, settings, "const VkPushDescriptorSetInfo*", "pPushDescriptorSetInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushDescriptorSetWithTemplate2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPushDescriptorSetWithTemplateInfo, settings, "const VkPushDescriptorSetWithTemplateInfo*", "pPushDescriptorSetWithTemplateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetWithTemplateInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDescriptorBufferOffsets2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSetDescriptorBufferOffsetsInfo, settings, "const VkSetDescriptorBufferOffsetsInfoEXT*", "pSetDescriptorBufferOffsetsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSetDescriptorBufferOffsetsInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBindDescriptorBufferEmbeddedSamplersInfo, settings, "const VkBindDescriptorBufferEmbeddedSamplersInfoEXT*", "pBindDescriptorBufferEmbeddedSamplersInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDescriptorBufferEmbeddedSamplersInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyMemoryIndirectKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyMemoryIndirectInfo, settings, "const VkCopyMemoryIndirectInfoKHR*", "pCopyMemoryIndirectInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryIndirectInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyMemoryToImageIndirectKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyMemoryToImageIndirectInfo, settings, "const VkCopyMemoryToImageIndirectInfoKHR*", "pCopyMemoryToImageIndirectInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToImageIndirectInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceFaultReportsKHR(ApiDumpInstance& dump_inst, VkDevice device, uint64_t timeout, uint32_t* pFaultCounts, VkDeviceFaultInfoKHR* pFaultInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(timeout, settings, "uint64_t", "timeout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFaultCounts, settings, "uint32_t*", "pFaultCounts", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pFaultInfo, *pFaultCounts, settings, "VkDeviceFaultInfoKHR*", "pFaultInfo", "VkDeviceFaultInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceFaultInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceFaultDebugInfoKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceFaultDebugInfoKHR* pDebugInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDebugInfo, settings, "VkDeviceFaultDebugInfoKHR*", "pDebugInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceFaultDebugInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndRendering2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderingEndInfo, settings, "const VkRenderingEndInfoKHR*", "pRenderingEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingEndInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDebugReportCallbackEXT(ApiDumpInstance& dump_inst, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDebugReportCallbackCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugReportCallbackCreateInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCallback, settings, "VkDebugReportCallbackEXT*", "pCallback", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugReportCallbackEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyDebugReportCallbackEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDebugReportCallbackEXT<Format>(callback, settings, "VkDebugReportCallbackEXT", "callback", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDebugReportMessageEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDebugReportFlagsEXT<Format>(flags, settings, "VkDebugReportFlagsEXT", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDebugReportObjectTypeEXT<Format>(objectType, settings, "VkDebugReportObjectTypeEXT", "objectType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(object, settings, "uint64_t", "object", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, size_t>(location, settings, "size_t", "location", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, int32_t>(messageCode, settings, "int32_t", "messageCode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_char<Format>(pLayerPrefix, settings, "const char*", "pLayerPrefix", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_char<Format>(pMessage, settings, "const char*", "pMessage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDebugMarkerSetObjectTagEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pTagInfo, settings, "const VkDebugMarkerObjectTagInfoEXT*", "pTagInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerObjectTagInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDebugMarkerSetObjectNameEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pNameInfo, settings, "const VkDebugMarkerObjectNameInfoEXT*", "pNameInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerObjectNameInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDebugMarkerBeginEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMarkerInfo, settings, "const VkDebugMarkerMarkerInfoEXT*", "pMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerMarkerInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDebugMarkerEndEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDebugMarkerInsertEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMarkerInfo, settings, "const VkDebugMarkerMarkerInfoEXT*", "pMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerMarkerInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindTransformFeedbackBuffersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstBinding, settings, "uint32_t", "firstBinding", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindingCount, settings, "uint32_t", "bindingCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBuffers, bindingCount, settings, "const VkBuffer*", "pBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pOffsets, bindingCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSizes, bindingCount, settings, "const VkDeviceSize*", "pSizes", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginTransformFeedbackEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstCounterBuffer, settings, "uint32_t", "firstCounterBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(counterBufferCount, settings, "uint32_t", "counterBufferCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCounterBuffers, counterBufferCount, settings, "const VkBuffer*", "pCounterBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCounterBufferOffsets, counterBufferCount, settings, "const VkDeviceSize*", "pCounterBufferOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndTransformFeedbackEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstCounterBuffer, settings, "uint32_t", "firstCounterBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(counterBufferCount, settings, "uint32_t", "counterBufferCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCounterBuffers, counterBufferCount, settings, "const VkBuffer*", "pCounterBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCounterBufferOffsets, counterBufferCount, settings, "const VkDeviceSize*", "pCounterBufferOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginQueryIndexedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryControlFlags<Format>(flags, settings, "VkQueryControlFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(index, settings, "uint32_t", "index", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndQueryIndexedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(index, settings, "uint32_t", "index", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndirectByteCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(instanceCount, settings, "uint32_t", "instanceCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstInstance, settings, "uint32_t", "firstInstance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(counterBuffer, settings, "VkBuffer", "counterBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(counterBufferOffset, settings, "VkDeviceSize", "counterBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(counterOffset, settings, "uint32_t", "counterOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(vertexStride, settings, "uint32_t", "vertexStride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateCuModuleNVX(ApiDumpInstance& dump_inst, VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkCuModuleCreateInfoNVX*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCuModuleCreateInfoNVX<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pModule, settings, "VkCuModuleNVX*", "pModule", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCuModuleNVX<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateCuFunctionNVX(ApiDumpInstance& dump_inst, VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkCuFunctionCreateInfoNVX*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCuFunctionCreateInfoNVX<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFunction, settings, "VkCuFunctionNVX*", "pFunction", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCuFunctionNVX<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyCuModuleNVX(ApiDumpInstance& dump_inst, VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCuModuleNVX<Format>(module, settings, "VkCuModuleNVX", "module", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyCuFunctionNVX(ApiDumpInstance& dump_inst, VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCuFunctionNVX<Format>(function, settings, "VkCuFunctionNVX", "function", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCuLaunchKernelNVX(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLaunchInfo, settings, "const VkCuLaunchInfoNVX*", "pLaunchInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCuLaunchInfoNVX<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageViewHandleNVX(ApiDumpInstance& dump_inst, VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkImageViewHandleInfoNVX*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewHandleInfoNVX<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageViewHandle64NVX(ApiDumpInstance& dump_inst, VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkImageViewHandleInfoNVX*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewHandleInfoNVX<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageViewAddressNVX(ApiDumpInstance& dump_inst, VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageView<Format>(imageView, settings, "VkImageView", "imageView", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pProperties, settings, "VkImageViewAddressPropertiesNVX*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewAddressPropertiesNVX<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceCombinedImageSamplerIndexNVX(ApiDumpInstance& dump_inst, VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(imageViewIndex, settings, "uint64_t", "imageViewIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(samplerIndex, settings, "uint64_t", "samplerIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndirectCountAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawIndexedIndirectCountAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetShaderInfoAMD(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderStageFlagBits<Format>(shaderStage, settings, "VkShaderStageFlagBits", "shaderStage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderInfoTypeAMD<Format>(infoType, settings, "VkShaderInfoTypeAMD", "infoType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfoSize, settings, "size_t*", "pInfoSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, size_t>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pInfo, settings, "void*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_GGP)

template <ApiDumpFormat Format>
void dump_params_vkCreateStreamDescriptorSurfaceGGP(ApiDumpInstance& dump_inst, VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkStreamDescriptorSurfaceCreateInfoGGP*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStreamDescriptorSurfaceCreateInfoGGP<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_GGP

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFormat<Format>(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageType<Format>(type, settings, "VkImageType", "type", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageTiling<Format>(tiling, settings, "VkImageTiling", "tiling", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageUsageFlags<Format>(usage, settings, "VkImageUsageFlags", "usage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageCreateFlags<Format>(flags, settings, "VkImageCreateFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkExternalMemoryHandleTypeFlagsNV<Format>(externalHandleType, settings, "VkExternalMemoryHandleTypeFlagsNV", "externalHandleType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalImageFormatProperties, settings, "VkExternalImageFormatPropertiesNV*", "pExternalImageFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalImageFormatPropertiesNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryWin32HandleNV(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeviceMemory<Format>(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkExternalMemoryHandleTypeFlagsNV<Format>(handleType, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pHandle, settings, "HANDLE*", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, HANDLE>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_VI_NN)

template <ApiDumpFormat Format>
void dump_params_vkCreateViSurfaceNN(ApiDumpInstance& dump_inst, VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkViSurfaceCreateInfoNN*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViSurfaceCreateInfoNN<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_VI_NN

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginConditionalRenderingEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pConditionalRenderingBegin, settings, "const VkConditionalRenderingBeginInfoEXT*", "pConditionalRenderingBegin", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkConditionalRenderingBeginInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndConditionalRenderingEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetViewportWScalingNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstViewport, settings, "uint32_t", "firstViewport", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pViewportWScalings, viewportCount, settings, "const VkViewportWScalingNV*", "pViewportWScalings", "const VkViewportWScalingNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViewportWScalingNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkReleaseDisplayEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDisplayKHR<Format>(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)

template <ApiDumpFormat Format>
void dump_params_vkAcquireXlibDisplayEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, Display*>(dpy, settings, "Display*", "dpy", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDisplayKHR<Format>(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetRandROutputDisplayEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, Display*>(dpy, settings, "Display*", "dpy", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, RROutput>(rrOutput, settings, "RROutput", "rrOutput", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDisplay, settings, "VkDisplayKHR*", "pDisplay", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_XLIB_XRANDR_EXT

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSurfaceCapabilities2EXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSurfaceKHR<Format>(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurfaceCapabilities, settings, "VkSurfaceCapabilities2EXT*", "pSurfaceCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCapabilities2EXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDisplayPowerControlEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDisplayKHR<Format>(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDisplayPowerInfo, settings, "const VkDisplayPowerInfoEXT*", "pDisplayPowerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPowerInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkRegisterDeviceEventEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDeviceEventInfo, settings, "const VkDeviceEventInfoEXT*", "pDeviceEventInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceEventInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFence, settings, "VkFence*", "pFence", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFence<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkRegisterDisplayEventEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDisplayKHR<Format>(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDisplayEventInfo, settings, "const VkDisplayEventInfoEXT*", "pDisplayEventInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayEventInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFence, settings, "VkFence*", "pFence", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFence<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSwapchainCounterEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSurfaceCounterFlagBitsEXT<Format>(counter, settings, "VkSurfaceCounterFlagBitsEXT", "counter", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCounterValue, settings, "uint64_t*", "pCounterValue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint64_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetRefreshCycleDurationGOOGLE(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDisplayTimingProperties, settings, "VkRefreshCycleDurationGOOGLE*", "pDisplayTimingProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRefreshCycleDurationGOOGLE<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPastPresentationTimingGOOGLE(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPresentationTimingCount, settings, "uint32_t*", "pPresentationTimingCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPresentationTimings, *pPresentationTimingCount, settings, "VkPastPresentationTimingGOOGLE*", "pPresentationTimings", "VkPastPresentationTimingGOOGLE", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPastPresentationTimingGOOGLE<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDiscardRectangleEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstDiscardRectangle, settings, "uint32_t", "firstDiscardRectangle", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(discardRectangleCount, settings, "uint32_t", "discardRectangleCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDiscardRectangles, discardRectangleCount, settings, "const VkRect2D*", "pDiscardRectangles", "const VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDiscardRectangleEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(discardRectangleEnable, settings, "VkBool32", "discardRectangleEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDiscardRectangleModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDiscardRectangleModeEXT<Format>(discardRectangleMode, settings, "VkDiscardRectangleModeEXT", "discardRectangleMode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetHdrMetadataEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(swapchainCount, settings, "uint32_t", "swapchainCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSwapchains, swapchainCount, settings, "const VkSwapchainKHR*", "pSwapchains", "const VkSwapchainKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pMetadata, swapchainCount, settings, "const VkHdrMetadataEXT*", "pMetadata", "const VkHdrMetadataEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHdrMetadataEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_IOS_MVK)

template <ApiDumpFormat Format>
void dump_params_vkCreateIOSSurfaceMVK(ApiDumpInstance& dump_inst, VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkIOSSurfaceCreateInfoMVK*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIOSSurfaceCreateInfoMVK<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_IOS_MVK
#if defined(VK_USE_PLATFORM_MACOS_MVK)

template <ApiDumpFormat Format>
void dump_params_vkCreateMacOSSurfaceMVK(ApiDumpInstance& dump_inst, VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkMacOSSurfaceCreateInfoMVK*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMacOSSurfaceCreateInfoMVK<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_MACOS_MVK

template <ApiDumpFormat Format>
void dump_params_vkSetDebugUtilsObjectNameEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pNameInfo, settings, "const VkDebugUtilsObjectNameInfoEXT*", "pNameInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsObjectNameInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetDebugUtilsObjectTagEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pTagInfo, settings, "const VkDebugUtilsObjectTagInfoEXT*", "pTagInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsObjectTagInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueBeginDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueEndDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkQueue queue) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueInsertDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdInsertDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDebugUtilsMessengerEXT(ApiDumpInstance& dump_inst, VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDebugUtilsMessengerCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsMessengerCreateInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMessenger, settings, "VkDebugUtilsMessengerEXT*", "pMessenger", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsMessengerEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyDebugUtilsMessengerEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDebugUtilsMessengerEXT<Format>(messenger, settings, "VkDebugUtilsMessengerEXT", "messenger", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSubmitDebugUtilsMessageEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDebugUtilsMessageSeverityFlagBitsEXT<Format>(messageSeverity, settings, "VkDebugUtilsMessageSeverityFlagBitsEXT", "messageSeverity", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDebugUtilsMessageTypeFlagsEXT<Format>(messageTypes, settings, "VkDebugUtilsMessageTypeFlagsEXT", "messageTypes", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCallbackData, settings, "const VkDebugUtilsMessengerCallbackDataEXT*", "pCallbackData", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsMessengerCallbackDataEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_ANDROID_KHR)

template <ApiDumpFormat Format>
void dump_params_vkGetAndroidHardwareBufferPropertiesANDROID(ApiDumpInstance& dump_inst, VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const struct AHardwareBuffer*>(buffer, settings, "const struct AHardwareBuffer*", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pProperties, settings, "VkAndroidHardwareBufferPropertiesANDROID*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAndroidHardwareBufferPropertiesANDROID<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryAndroidHardwareBufferANDROID(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkMemoryGetAndroidHardwareBufferInfoANDROID*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetAndroidHardwareBufferInfoANDROID<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, struct AHardwareBuffer**>(pBuffer, settings, "struct AHardwareBuffer**", "pBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_ANDROID_KHR

template <ApiDumpFormat Format>
void dump_params_vkCreateGpaSessionAMD(ApiDumpInstance& dump_inst, VkDevice device, const VkGpaSessionCreateInfoAMD* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkGpaSessionAMD* pGpaSession) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkGpaSessionCreateInfoAMD*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGpaSessionCreateInfoAMD<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGpaSession, settings, "VkGpaSessionAMD*", "pGpaSession", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGpaSessionAMD<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyGpaSessionAMD(ApiDumpInstance& dump_inst, VkDevice device, VkGpaSessionAMD gpaSession, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkGpaSessionAMD<Format>(gpaSession, settings, "VkGpaSessionAMD", "gpaSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetGpaDeviceClockModeAMD(ApiDumpInstance& dump_inst, VkDevice device, VkGpaDeviceClockModeInfoAMD* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "VkGpaDeviceClockModeInfoAMD*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGpaDeviceClockModeInfoAMD<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetGpaDeviceClockInfoAMD(ApiDumpInstance& dump_inst, VkDevice device, VkGpaDeviceGetClockInfoAMD* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "VkGpaDeviceGetClockInfoAMD*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGpaDeviceGetClockInfoAMD<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginGpaSessionAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkGpaSessionAMD<Format>(gpaSession, settings, "VkGpaSessionAMD", "gpaSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndGpaSessionAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkGpaSessionAMD<Format>(gpaSession, settings, "VkGpaSessionAMD", "gpaSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginGpaSampleAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, const VkGpaSampleBeginInfoAMD* pGpaSampleBeginInfo, uint32_t* pSampleID) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkGpaSessionAMD<Format>(gpaSession, settings, "VkGpaSessionAMD", "gpaSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGpaSampleBeginInfo, settings, "const VkGpaSampleBeginInfoAMD*", "pGpaSampleBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGpaSampleBeginInfoAMD<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSampleID, settings, "uint32_t*", "pSampleID", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndGpaSampleAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, uint32_t sampleID) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkGpaSessionAMD<Format>(gpaSession, settings, "VkGpaSessionAMD", "gpaSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(sampleID, settings, "uint32_t", "sampleID", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetGpaSessionStatusAMD(ApiDumpInstance& dump_inst, VkDevice device, VkGpaSessionAMD gpaSession) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkGpaSessionAMD<Format>(gpaSession, settings, "VkGpaSessionAMD", "gpaSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetGpaSessionResultsAMD(ApiDumpInstance& dump_inst, VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID, size_t* pSizeInBytes, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkGpaSessionAMD<Format>(gpaSession, settings, "VkGpaSessionAMD", "gpaSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(sampleID, settings, "uint32_t", "sampleID", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSizeInBytes, settings, "size_t*", "pSizeInBytes", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, size_t>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkResetGpaSessionAMD(ApiDumpInstance& dump_inst, VkDevice device, VkGpaSessionAMD gpaSession) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkGpaSessionAMD<Format>(gpaSession, settings, "VkGpaSessionAMD", "gpaSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyGpaSessionResultsAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkGpaSessionAMD<Format>(gpaSession, settings, "VkGpaSessionAMD", "gpaSession", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)

template <ApiDumpFormat Format>
void dump_params_vkCreateExecutionGraphPipelinesAMDX(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineCache<Format>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCreateInfos, createInfoCount, settings, "const VkExecutionGraphPipelineCreateInfoAMDX*", "pCreateInfos", "const VkExecutionGraphPipelineCreateInfoAMDX", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExecutionGraphPipelineCreateInfoAMDX<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetExecutionGraphPipelineScratchSizeAMDX(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(executionGraph, settings, "VkPipeline", "executionGraph", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSizeInfo, settings, "VkExecutionGraphPipelineScratchSizeAMDX*", "pSizeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExecutionGraphPipelineScratchSizeAMDX<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetExecutionGraphPipelineNodeIndexAMDX(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(executionGraph, settings, "VkPipeline", "executionGraph", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pNodeInfo, settings, "const VkPipelineShaderStageNodeCreateInfoAMDX*", "pNodeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineShaderStageNodeCreateInfoAMDX<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pNodeIndex, settings, "uint32_t*", "pNodeIndex", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdInitializeGraphScratchMemoryAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(executionGraph, settings, "VkPipeline", "executionGraph", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(scratch, settings, "VkDeviceAddress", "scratch", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(scratchSize, settings, "VkDeviceSize", "scratchSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDispatchGraphAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(scratch, settings, "VkDeviceAddress", "scratch", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(scratchSize, settings, "VkDeviceSize", "scratchSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCountInfo, settings, "const VkDispatchGraphCountInfoAMDX*", "pCountInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDispatchGraphCountInfoAMDX<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDispatchGraphIndirectAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(scratch, settings, "VkDeviceAddress", "scratch", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(scratchSize, settings, "VkDeviceSize", "scratchSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCountInfo, settings, "const VkDispatchGraphCountInfoAMDX*", "pCountInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDispatchGraphCountInfoAMDX<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDispatchGraphIndirectCountAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(scratch, settings, "VkDeviceAddress", "scratch", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(scratchSize, settings, "VkDeviceSize", "scratchSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(countInfo, settings, "VkDeviceAddress", "countInfo", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_ENABLE_BETA_EXTENSIONS

template <ApiDumpFormat Format>
void dump_params_vkWriteSamplerDescriptorsEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t samplerCount, const VkSamplerCreateInfo* pSamplers, const VkHostAddressRangeEXT* pDescriptors) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(samplerCount, settings, "uint32_t", "samplerCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSamplers, samplerCount, settings, "const VkSamplerCreateInfo*", "pSamplers", "const VkSamplerCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDescriptors, samplerCount, settings, "const VkHostAddressRangeEXT*", "pDescriptors", "const VkHostAddressRangeEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkWriteResourceDescriptorsEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t resourceCount, const VkResourceDescriptorInfoEXT* pResources, const VkHostAddressRangeEXT* pDescriptors) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(resourceCount, settings, "uint32_t", "resourceCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pResources, resourceCount, settings, "const VkResourceDescriptorInfoEXT*", "pResources", "const VkResourceDescriptorInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkResourceDescriptorInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDescriptors, resourceCount, settings, "const VkHostAddressRangeEXT*", "pDescriptors", "const VkHostAddressRangeEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindSamplerHeapEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBindInfo, settings, "const VkBindHeapInfoEXT*", "pBindInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindHeapInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindResourceHeapEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBindInfo, settings, "const VkBindHeapInfoEXT*", "pBindInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindHeapInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPushDataEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPushDataInfo, settings, "const VkPushDataInfoEXT*", "pPushDataInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDataInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageOpaqueCaptureDataEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t imageCount, const VkImage* pImages, VkHostAddressRangeEXT* pDatas) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(imageCount, settings, "uint32_t", "imageCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pImages, imageCount, settings, "const VkImage*", "pImages", "const VkImage", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImage<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDatas, imageCount, settings, "VkHostAddressRangeEXT*", "pDatas", "VkHostAddressRangeEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceDescriptorSizeEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorType<Format>(descriptorType, settings, "VkDescriptorType", "descriptorType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkRegisterCustomBorderColorEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, VkBool32 requestIndex, uint32_t* pIndex) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBorderColor, settings, "const VkSamplerCustomBorderColorCreateInfoEXT*", "pBorderColor", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCustomBorderColorCreateInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(requestIndex, settings, "VkBool32", "requestIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pIndex, settings, "uint32_t*", "pIndex", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkUnregisterCustomBorderColorEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t index) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(index, settings, "uint32_t", "index", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetTensorOpaqueCaptureDataARM(ApiDumpInstance& dump_inst, VkDevice device, uint32_t tensorCount, const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(tensorCount, settings, "uint32_t", "tensorCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pTensors, tensorCount, settings, "const VkTensorARM*", "pTensors", "const VkTensorARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDatas, tensorCount, settings, "VkHostAddressRangeEXT*", "pDatas", "VkHostAddressRangeEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetSampleLocationsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSampleLocationsInfo, settings, "const VkSampleLocationsInfoEXT*", "pSampleLocationsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSampleLocationsInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceMultisamplePropertiesEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSampleCountFlagBits<Format>(samples, settings, "VkSampleCountFlagBits", "samples", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMultisampleProperties, settings, "VkMultisamplePropertiesEXT*", "pMultisampleProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMultisamplePropertiesEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageDrmFormatModifierPropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pProperties, settings, "VkImageDrmFormatModifierPropertiesEXT*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageDrmFormatModifierPropertiesEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateValidationCacheEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkValidationCacheCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkValidationCacheCreateInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pValidationCache, settings, "VkValidationCacheEXT*", "pValidationCache", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkValidationCacheEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyValidationCacheEXT(ApiDumpInstance& dump_inst, VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkValidationCacheEXT<Format>(validationCache, settings, "VkValidationCacheEXT", "validationCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkMergeValidationCachesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkValidationCacheEXT<Format>(dstCache, settings, "VkValidationCacheEXT", "dstCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(srcCacheCount, settings, "uint32_t", "srcCacheCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSrcCaches, srcCacheCount, settings, "const VkValidationCacheEXT*", "pSrcCaches", "const VkValidationCacheEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkValidationCacheEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetValidationCacheDataEXT(ApiDumpInstance& dump_inst, VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkValidationCacheEXT<Format>(validationCache, settings, "VkValidationCacheEXT", "validationCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDataSize, settings, "size_t*", "pDataSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, size_t>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindShadingRateImageNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageView<Format>(imageView, settings, "VkImageView", "imageView", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(imageLayout, settings, "VkImageLayout", "imageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetViewportShadingRatePaletteNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstViewport, settings, "uint32_t", "firstViewport", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pShadingRatePalettes, viewportCount, settings, "const VkShadingRatePaletteNV*", "pShadingRatePalettes", "const VkShadingRatePaletteNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShadingRatePaletteNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetCoarseSampleOrderNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCoarseSampleOrderTypeNV<Format>(sampleOrderType, settings, "VkCoarseSampleOrderTypeNV", "sampleOrderType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(customSampleOrderCount, settings, "uint32_t", "customSampleOrderCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCustomSampleOrders, customSampleOrderCount, settings, "const VkCoarseSampleOrderCustomNV*", "pCustomSampleOrders", "const VkCoarseSampleOrderCustomNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCoarseSampleOrderCustomNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateAccelerationStructureNV(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkAccelerationStructureCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCreateInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAccelerationStructure, settings, "VkAccelerationStructureNV*", "pAccelerationStructure", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyAccelerationStructureNV(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkAccelerationStructureNV<Format>(accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetAccelerationStructureMemoryRequirementsNV(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkAccelerationStructureMemoryRequirementsInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureMemoryRequirementsInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBindAccelerationStructureMemoryNV(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindInfos, bindInfoCount, settings, "const VkBindAccelerationStructureMemoryInfoNV*", "pBindInfos", "const VkBindAccelerationStructureMemoryInfoNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindAccelerationStructureMemoryInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBuildAccelerationStructureNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkAccelerationStructureInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(instanceData, settings, "VkBuffer", "instanceData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(instanceOffset, settings, "VkDeviceSize", "instanceOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(update, settings, "VkBool32", "update", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkAccelerationStructureNV<Format>(dst, settings, "VkAccelerationStructureNV", "dst", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkAccelerationStructureNV<Format>(src, settings, "VkAccelerationStructureNV", "src", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(scratch, settings, "VkBuffer", "scratch", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(scratchOffset, settings, "VkDeviceSize", "scratchOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyAccelerationStructureNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkAccelerationStructureNV<Format>(dst, settings, "VkAccelerationStructureNV", "dst", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkAccelerationStructureNV<Format>(src, settings, "VkAccelerationStructureNV", "src", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCopyAccelerationStructureModeKHR<Format>(mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdTraceRaysNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(raygenShaderBindingTableBuffer, settings, "VkBuffer", "raygenShaderBindingTableBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(raygenShaderBindingOffset, settings, "VkDeviceSize", "raygenShaderBindingOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(missShaderBindingTableBuffer, settings, "VkBuffer", "missShaderBindingTableBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(missShaderBindingOffset, settings, "VkDeviceSize", "missShaderBindingOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(missShaderBindingStride, settings, "VkDeviceSize", "missShaderBindingStride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(hitShaderBindingTableBuffer, settings, "VkBuffer", "hitShaderBindingTableBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(hitShaderBindingOffset, settings, "VkDeviceSize", "hitShaderBindingOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(hitShaderBindingStride, settings, "VkDeviceSize", "hitShaderBindingStride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(callableShaderBindingTableBuffer, settings, "VkBuffer", "callableShaderBindingTableBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(callableShaderBindingOffset, settings, "VkDeviceSize", "callableShaderBindingOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(callableShaderBindingStride, settings, "VkDeviceSize", "callableShaderBindingStride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(width, settings, "uint32_t", "width", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(height, settings, "uint32_t", "height", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(depth, settings, "uint32_t", "depth", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateRayTracingPipelinesNV(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineCache<Format>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCreateInfos, createInfoCount, settings, "const VkRayTracingPipelineCreateInfoNV*", "pCreateInfos", "const VkRayTracingPipelineCreateInfoNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRayTracingPipelineCreateInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetRayTracingShaderGroupHandlesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstGroup, settings, "uint32_t", "firstGroup", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCount, settings, "uint32_t", "groupCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, size_t>(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetRayTracingShaderGroupHandlesNV(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstGroup, settings, "uint32_t", "firstGroup", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCount, settings, "uint32_t", "groupCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, size_t>(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetAccelerationStructureHandleNV(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkAccelerationStructureNV<Format>(accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, size_t>(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWriteAccelerationStructuresPropertiesNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pAccelerationStructures, accelerationStructureCount, settings, "const VkAccelerationStructureNV*", "pAccelerationStructures", "const VkAccelerationStructureNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureNV<Format>);
        dump_separate_members<Format>(settings);
        dump_VkQueryType<Format>(queryType, settings, "VkQueryType", "queryType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCompileDeferredNV(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, uint32_t shader) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(shader, settings, "uint32_t", "shader", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryHostPointerPropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkExternalMemoryHandleTypeFlagBits<Format>(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const void*>(pHostPointer, settings, "const void*", "pHostPointer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryHostPointerProperties, settings, "VkMemoryHostPointerPropertiesEXT*", "pMemoryHostPointerProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryHostPointerPropertiesEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWriteBufferMarkerAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlagBits<Format>(pipelineStage, settings, "VkPipelineStageFlagBits", "pipelineStage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(dstOffset, settings, "VkDeviceSize", "dstOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(marker, settings, "uint32_t", "marker", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWriteBufferMarker2AMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineStageFlags2<Format>(stage, settings, "VkPipelineStageFlags2", "stage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(dstOffset, settings, "VkDeviceSize", "dstOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(marker, settings, "uint32_t", "marker", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pTimeDomainCount, settings, "uint32_t*", "pTimeDomainCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pTimeDomains, *pTimeDomainCount, settings, "VkTimeDomainKHR*", "pTimeDomains", "VkTimeDomainKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTimeDomainKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetCalibratedTimestampsEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(timestampCount, settings, "uint32_t", "timestampCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pTimestampInfos, timestampCount, settings, "const VkCalibratedTimestampInfoKHR*", "pTimestampInfos", "const VkCalibratedTimestampInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCalibratedTimestampInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pTimestamps, timestampCount, settings, "uint64_t*", "pTimestamps", "uint64_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint64_t>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMaxDeviation, settings, "uint64_t*", "pMaxDeviation", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint64_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawMeshTasksNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(taskCount, settings, "uint32_t", "taskCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstTask, settings, "uint32_t", "firstTask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawMeshTasksIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawMeshTasksIndirectCountNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetExclusiveScissorEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstExclusiveScissor, settings, "uint32_t", "firstExclusiveScissor", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(exclusiveScissorCount, settings, "uint32_t", "exclusiveScissorCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pExclusiveScissorEnables, exclusiveScissorCount, settings, "const VkBool32*", "pExclusiveScissorEnables", "const VkBool32", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkBool32>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetExclusiveScissorNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstExclusiveScissor, settings, "uint32_t", "firstExclusiveScissor", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(exclusiveScissorCount, settings, "uint32_t", "exclusiveScissorCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pExclusiveScissors, exclusiveScissorCount, settings, "const VkRect2D*", "pExclusiveScissors", "const VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetCheckpointNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const void* pCheckpointMarker) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const void*>(pCheckpointMarker, settings, "const void*", "pCheckpointMarker", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetQueueCheckpointDataNV(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCheckpointDataCount, settings, "uint32_t*", "pCheckpointDataCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCheckpointData, *pCheckpointDataCount, settings, "VkCheckpointDataNV*", "pCheckpointData", "VkCheckpointDataNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCheckpointDataNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetQueueCheckpointData2NV(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCheckpointDataCount, settings, "uint32_t*", "pCheckpointDataCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCheckpointData, *pCheckpointDataCount, settings, "VkCheckpointData2NV*", "pCheckpointData", "VkCheckpointData2NV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCheckpointData2NV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetSwapchainPresentTimingQueueSizeEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, uint32_t size) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(size, settings, "uint32_t", "size", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSwapchainTimingPropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, uint64_t* pSwapchainTimingPropertiesCounter) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSwapchainTimingProperties, settings, "VkSwapchainTimingPropertiesEXT*", "pSwapchainTimingProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainTimingPropertiesEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSwapchainTimingPropertiesCounter, settings, "uint64_t*", "pSwapchainTimingPropertiesCounter", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint64_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSwapchainTimeDomainPropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, uint64_t* pTimeDomainsCounter) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSwapchainTimeDomainProperties, settings, "VkSwapchainTimeDomainPropertiesEXT*", "pSwapchainTimeDomainProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainTimeDomainPropertiesEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pTimeDomainsCounter, settings, "uint64_t*", "pTimeDomainsCounter", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint64_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPastPresentationTimingEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPastPresentationTimingInfo, settings, "const VkPastPresentationTimingInfoEXT*", "pPastPresentationTimingInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPastPresentationTimingInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPastPresentationTimingProperties, settings, "VkPastPresentationTimingPropertiesEXT*", "pPastPresentationTimingProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPastPresentationTimingPropertiesEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkInitializePerformanceApiINTEL(ApiDumpInstance& dump_inst, VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInitializeInfo, settings, "const VkInitializePerformanceApiInfoINTEL*", "pInitializeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkInitializePerformanceApiInfoINTEL<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkUninitializePerformanceApiINTEL(ApiDumpInstance& dump_inst, VkDevice device) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetPerformanceMarkerINTEL(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMarkerInfo, settings, "const VkPerformanceMarkerInfoINTEL*", "pMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceMarkerInfoINTEL<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetPerformanceStreamMarkerINTEL(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMarkerInfo, settings, "const VkPerformanceStreamMarkerInfoINTEL*", "pMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceStreamMarkerInfoINTEL<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetPerformanceOverrideINTEL(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pOverrideInfo, settings, "const VkPerformanceOverrideInfoINTEL*", "pOverrideInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceOverrideInfoINTEL<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkAcquirePerformanceConfigurationINTEL(ApiDumpInstance& dump_inst, VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAcquireInfo, settings, "const VkPerformanceConfigurationAcquireInfoINTEL*", "pAcquireInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceConfigurationAcquireInfoINTEL<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pConfiguration, settings, "VkPerformanceConfigurationINTEL*", "pConfiguration", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceConfigurationINTEL<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkReleasePerformanceConfigurationINTEL(ApiDumpInstance& dump_inst, VkDevice device, VkPerformanceConfigurationINTEL configuration) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPerformanceConfigurationINTEL<Format>(configuration, settings, "VkPerformanceConfigurationINTEL", "configuration", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueSetPerformanceConfigurationINTEL(ApiDumpInstance& dump_inst, VkQueue queue, VkPerformanceConfigurationINTEL configuration) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPerformanceConfigurationINTEL<Format>(configuration, settings, "VkPerformanceConfigurationINTEL", "configuration", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPerformanceParameterINTEL(ApiDumpInstance& dump_inst, VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPerformanceParameterTypeINTEL<Format>(parameter, settings, "VkPerformanceParameterTypeINTEL", "parameter", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pValue, settings, "VkPerformanceValueINTEL*", "pValue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceValueINTEL<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetLocalDimmingAMD(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapChain, settings, "VkSwapchainKHR", "swapChain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(localDimmingEnable, settings, "VkBool32", "localDimmingEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_FUCHSIA)

template <ApiDumpFormat Format>
void dump_params_vkCreateImagePipeSurfaceFUCHSIA(ApiDumpInstance& dump_inst, VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkImagePipeSurfaceCreateInfoFUCHSIA*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImagePipeSurfaceCreateInfoFUCHSIA<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_METAL_EXT)

template <ApiDumpFormat Format>
void dump_params_vkCreateMetalSurfaceEXT(ApiDumpInstance& dump_inst, VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkMetalSurfaceCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMetalSurfaceCreateInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_METAL_EXT

template <ApiDumpFormat Format>
void dump_params_vkGetBufferDeviceAddressEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceToolPropertiesEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pToolCount, settings, "uint32_t*", "pToolCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pToolProperties, *pToolCount, settings, "VkPhysicalDeviceToolProperties*", "pToolProperties", "VkPhysicalDeviceToolProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceToolProperties<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkCooperativeMatrixPropertiesNV*", "pProperties", "VkCooperativeMatrixPropertiesNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeMatrixPropertiesNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCombinationCount, settings, "uint32_t*", "pCombinationCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCombinations, *pCombinationCount, settings, "VkFramebufferMixedSamplesCombinationNV*", "pCombinations", "VkFramebufferMixedSamplesCombinationNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFramebufferMixedSamplesCombinationNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceSurfacePresentModes2EXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPresentModeCount, settings, "uint32_t*", "pPresentModeCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPresentModes, *pPresentModeCount, settings, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentModeKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkAcquireFullScreenExclusiveModeEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkReleaseFullScreenExclusiveModeEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceGroupSurfacePresentModes2EXT(ApiDumpInstance& dump_inst, VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pModes, settings, "VkDeviceGroupPresentModeFlagsKHR*", "pModes", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceGroupPresentModeFlagsKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

template <ApiDumpFormat Format>
void dump_params_vkCreateHeadlessSurfaceEXT(ApiDumpInstance& dump_inst, VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkHeadlessSurfaceCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHeadlessSurfaceCreateInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetLineStippleEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(lineStippleFactor, settings, "uint32_t", "lineStippleFactor", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint16_t>(lineStipplePattern, settings, "uint16_t", "lineStipplePattern", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkResetQueryPoolEXT(ApiDumpInstance& dump_inst, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queryCount, settings, "uint32_t", "queryCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetCullModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCullModeFlags<Format>(cullMode, settings, "VkCullModeFlags", "cullMode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetFrontFaceEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFrontFace<Format>(frontFace, settings, "VkFrontFace", "frontFace", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetPrimitiveTopologyEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPrimitiveTopology<Format>(primitiveTopology, settings, "VkPrimitiveTopology", "primitiveTopology", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetViewportWithCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pViewports, viewportCount, settings, "const VkViewport*", "pViewports", "const VkViewport", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViewport<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetScissorWithCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(scissorCount, settings, "uint32_t", "scissorCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pScissors, scissorCount, settings, "const VkRect2D*", "pScissors", "const VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindVertexBuffers2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstBinding, settings, "uint32_t", "firstBinding", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindingCount, settings, "uint32_t", "bindingCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBuffers, bindingCount, settings, "const VkBuffer*", "pBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pOffsets, bindingCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSizes, bindingCount, settings, "const VkDeviceSize*", "pSizes", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pStrides, bindingCount, settings, "const VkDeviceSize*", "pStrides", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthTestEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(depthTestEnable, settings, "VkBool32", "depthTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthWriteEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(depthWriteEnable, settings, "VkBool32", "depthWriteEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthCompareOpEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCompareOp<Format>(depthCompareOp, settings, "VkCompareOp", "depthCompareOp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthBoundsTestEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(depthBoundsTestEnable, settings, "VkBool32", "depthBoundsTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetStencilTestEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(stencilTestEnable, settings, "VkBool32", "stencilTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetStencilOpEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkStencilFaceFlags<Format>(faceMask, settings, "VkStencilFaceFlags", "faceMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkStencilOp<Format>(failOp, settings, "VkStencilOp", "failOp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkStencilOp<Format>(passOp, settings, "VkStencilOp", "passOp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkStencilOp<Format>(depthFailOp, settings, "VkStencilOp", "depthFailOp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCompareOp<Format>(compareOp, settings, "VkCompareOp", "compareOp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyMemoryToImageEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyMemoryToImageInfo, settings, "const VkCopyMemoryToImageInfo*", "pCopyMemoryToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToImageInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyImageToMemoryEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyImageToMemoryInfo, settings, "const VkCopyImageToMemoryInfo*", "pCopyImageToMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToMemoryInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyImageToImageEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyImageToImageInfo, settings, "const VkCopyImageToImageInfo*", "pCopyImageToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToImageInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkTransitionImageLayoutEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(transitionCount, settings, "uint32_t", "transitionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pTransitions, transitionCount, settings, "const VkHostImageLayoutTransitionInfo*", "pTransitions", "const VkHostImageLayoutTransitionInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostImageLayoutTransitionInfo<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageSubresourceLayout2EXT(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSubresource, settings, "const VkImageSubresource2*", "pSubresource", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource2<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLayout, settings, "VkSubresourceLayout2*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkReleaseSwapchainImagesEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pReleaseInfo, settings, "const VkReleaseSwapchainImagesInfoKHR*", "pReleaseInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkReleaseSwapchainImagesInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetGeneratedCommandsMemoryRequirementsNV(ApiDumpInstance& dump_inst, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkGeneratedCommandsMemoryRequirementsInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsMemoryRequirementsInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPreprocessGeneratedCommandsNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoNV*", "pGeneratedCommandsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdExecuteGeneratedCommandsNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(isPreprocessed, settings, "VkBool32", "isPreprocessed", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoNV*", "pGeneratedCommandsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindPipelineShaderGroupNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineBindPoint<Format>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupIndex, settings, "uint32_t", "groupIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateIndirectCommandsLayoutNV(ApiDumpInstance& dump_inst, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkIndirectCommandsLayoutCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutCreateInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pIndirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV*", "pIndirectCommandsLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyIndirectCommandsLayoutNV(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkIndirectCommandsLayoutNV<Format>(indirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthBias2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDepthBiasInfo, settings, "const VkDepthBiasInfoEXT*", "pDepthBiasInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDepthBiasInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkAcquireDrmDisplayEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, int32_t>(drmFd, settings, "int32_t", "drmFd", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDisplayKHR<Format>(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDrmDisplayEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, int32_t>(drmFd, settings, "int32_t", "drmFd", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(connectorId, settings, "uint32_t", "connectorId", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(display, settings, "VkDisplayKHR*", "display", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreatePrivateDataSlotEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkPrivateDataSlotCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlotCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPrivateDataSlot, settings, "VkPrivateDataSlot*", "pPrivateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlot<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyPrivateDataSlotEXT(ApiDumpInstance& dump_inst, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPrivateDataSlot<Format>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetPrivateDataEXT(ApiDumpInstance& dump_inst, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkObjectType<Format>(objectType, settings, "VkObjectType", "objectType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_uint64_t_as_pointer<Format>(objectHandle, settings, "uint64_t", "objectHandle", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPrivateDataSlot<Format>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(data, settings, "uint64_t", "data", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPrivateDataEXT(ApiDumpInstance& dump_inst, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkObjectType<Format>(objectType, settings, "VkObjectType", "objectType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_uint64_t_as_pointer<Format>(objectHandle, settings, "uint64_t", "objectHandle", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPrivateDataSlot<Format>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pData, settings, "uint64_t*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint64_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueSetPerfHintQCOM(ApiDumpInstance& dump_inst, VkQueue queue, const VkPerfHintInfoQCOM* pPerfHintInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPerfHintInfo, settings, "const VkPerfHintInfoQCOM*", "pPerfHintInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerfHintInfoQCOM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)

template <ApiDumpFormat Format>
void dump_params_vkCreateCudaModuleNV(ApiDumpInstance& dump_inst, VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkCudaModuleCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaModuleCreateInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pModule, settings, "VkCudaModuleNV*", "pModule", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaModuleNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetCudaModuleCacheNV(ApiDumpInstance& dump_inst, VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCudaModuleNV<Format>(module, settings, "VkCudaModuleNV", "module", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCacheSize, settings, "size_t*", "pCacheSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, size_t>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pCacheData, settings, "void*", "pCacheData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateCudaFunctionNV(ApiDumpInstance& dump_inst, VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkCudaFunctionCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaFunctionCreateInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFunction, settings, "VkCudaFunctionNV*", "pFunction", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaFunctionNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyCudaModuleNV(ApiDumpInstance& dump_inst, VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCudaModuleNV<Format>(module, settings, "VkCudaModuleNV", "module", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyCudaFunctionNV(ApiDumpInstance& dump_inst, VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCudaFunctionNV<Format>(function, settings, "VkCudaFunctionNV", "function", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCudaLaunchKernelNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLaunchInfo, settings, "const VkCudaLaunchInfoNV*", "pLaunchInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaLaunchInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_ENABLE_BETA_EXTENSIONS

template <ApiDumpFormat Format>
void dump_params_vkCmdDispatchTileQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM* pDispatchTileInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDispatchTileInfo, settings, "const VkDispatchTileInfoQCOM*", "pDispatchTileInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDispatchTileInfoQCOM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginPerTileExecutionQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPerTileBeginInfo, settings, "const VkPerTileBeginInfoQCOM*", "pPerTileBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerTileBeginInfoQCOM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndPerTileExecutionQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPerTileEndInfo, settings, "const VkPerTileEndInfoQCOM*", "pPerTileEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerTileEndInfoQCOM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetLatencySleepModeLegacyNV(ApiDumpInstance& dump_inst, VkDevice device, VkBool32 lowLatencyMode, VkBool32 lowLatencyBoost, uint32_t minimumIntervalUs) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(lowLatencyMode, settings, "VkBool32", "lowLatencyMode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(lowLatencyBoost, settings, "VkBool32", "lowLatencyBoost", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(minimumIntervalUs, settings, "uint32_t", "minimumIntervalUs", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkLatencySleepLegacyNV(ApiDumpInstance& dump_inst, VkDevice device, VkSemaphore signalSemaphore, uint64_t value) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSemaphore<Format>(signalSemaphore, settings, "VkSemaphore", "signalSemaphore", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(value, settings, "uint64_t", "value", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetLatencyMarkerLegacyNV(ApiDumpInstance& dump_inst, VkDevice device, uint64_t frameID, uint32_t marker) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint64_t>(frameID, settings, "uint64_t", "frameID", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(marker, settings, "uint32_t", "marker", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetLatencyTimingsLegacyNV(ApiDumpInstance& dump_inst, VkDevice device, void* pTimings) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pTimings, settings, "void*", "pTimings", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueNotifyOutOfBandLegacyNV(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t queueType) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueType, settings, "uint32_t", "queueType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSleepStatusLegacyNV(ApiDumpInstance& dump_inst, VkDevice device, VkBool32* pLowLatencyMode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLowLatencyMode, settings, "VkBool32*", "pLowLatencyMode", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, VkBool32>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkShutdownLatencyDeviceLegacyNV(ApiDumpInstance& dump_inst, VkDevice device) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_METAL_EXT)

template <ApiDumpFormat Format>
void dump_params_vkExportMetalObjectsEXT(ApiDumpInstance& dump_inst, VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMetalObjectsInfo, settings, "VkExportMetalObjectsInfoEXT*", "pMetalObjectsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExportMetalObjectsInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_METAL_EXT

template <ApiDumpFormat Format>
void dump_params_vkGetDescriptorSetLayoutSizeEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorSetLayout<Format>(layout, settings, "VkDescriptorSetLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLayoutSizeInBytes, settings, "VkDeviceSize*", "pLayoutSizeInBytes", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, VkDeviceSize>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDescriptorSetLayoutBindingOffsetEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorSetLayout<Format>(layout, settings, "VkDescriptorSetLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(binding, settings, "uint32_t", "binding", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pOffset, settings, "VkDeviceSize*", "pOffset", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, VkDeviceSize>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDescriptorEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDescriptorInfo, settings, "const VkDescriptorGetInfoEXT*", "pDescriptorInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorGetInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, size_t>(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pDescriptor, settings, "void*", "pDescriptor", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindDescriptorBuffersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bufferCount, settings, "uint32_t", "bufferCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindingInfos, bufferCount, settings, "const VkDescriptorBufferBindingInfoEXT*", "pBindingInfos", "const VkDescriptorBufferBindingInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorBufferBindingInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDescriptorBufferOffsetsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineBindPoint<Format>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineLayout<Format>(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstSet, settings, "uint32_t", "firstSet", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(setCount, settings, "uint32_t", "setCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBufferIndices, setCount, settings, "const uint32_t*", "pBufferIndices", "const uint32_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pOffsets, setCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceSize>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineBindPoint<Format>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineLayout<Format>(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(set, settings, "uint32_t", "set", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetBufferOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkBufferCaptureDescriptorDataInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCaptureDescriptorDataInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkImageCaptureDescriptorDataInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageCaptureDescriptorDataInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetImageViewOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkImageViewCaptureDescriptorDataInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewCaptureDescriptorDataInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSamplerOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkSamplerCaptureDescriptorDataInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCaptureDescriptorDataInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkAccelerationStructureCaptureDescriptorDataInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCaptureDescriptorDataInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetFragmentShadingRateEnumNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFragmentShadingRateNV<Format>(shadingRate, settings, "VkFragmentShadingRateNV", "shadingRate", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(combinerOps, 2, settings, "const VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "const VkFragmentShadingRateCombinerOpKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFragmentShadingRateCombinerOpKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceFaultInfoEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFaultCounts, settings, "VkDeviceFaultCountsEXT*", "pFaultCounts", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceFaultCountsEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFaultInfo, settings, "VkDeviceFaultInfoEXT*", "pFaultInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceFaultInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)

template <ApiDumpFormat Format>
void dump_params_vkAcquireWinrtDisplayNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDisplayKHR<Format>(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetWinrtDisplayNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(deviceRelativeId, settings, "uint32_t", "deviceRelativeId", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDisplay, settings, "VkDisplayKHR*", "pDisplay", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)

template <ApiDumpFormat Format>
void dump_params_vkCreateDirectFBSurfaceEXT(ApiDumpInstance& dump_inst, VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDirectFBSurfaceCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDirectFBSurfaceCreateInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, IDirectFB*>(dfb, settings, "IDirectFB*", "dfb", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_DIRECTFB_EXT

template <ApiDumpFormat Format>
void dump_params_vkCmdSetVertexInputEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(vertexBindingDescriptionCount, settings, "uint32_t", "vertexBindingDescriptionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pVertexBindingDescriptions, vertexBindingDescriptionCount, settings, "const VkVertexInputBindingDescription2EXT*", "pVertexBindingDescriptions", "const VkVertexInputBindingDescription2EXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVertexInputBindingDescription2EXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(vertexAttributeDescriptionCount, settings, "uint32_t", "vertexAttributeDescriptionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pVertexAttributeDescriptions, vertexAttributeDescriptionCount, settings, "const VkVertexInputAttributeDescription2EXT*", "pVertexAttributeDescriptions", "const VkVertexInputAttributeDescription2EXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVertexInputAttributeDescription2EXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_FUCHSIA)

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryZirconHandleFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGetZirconHandleInfo, settings, "const VkMemoryGetZirconHandleInfoFUCHSIA*", "pGetZirconHandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetZirconHandleInfoFUCHSIA<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pZirconHandle, settings, "zx_handle_t*", "pZirconHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, zx_handle_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryZirconHandlePropertiesFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkExternalMemoryHandleTypeFlagBits<Format>(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, zx_handle_t>(zirconHandle, settings, "zx_handle_t", "zirconHandle", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryZirconHandleProperties, settings, "VkMemoryZirconHandlePropertiesFUCHSIA*", "pMemoryZirconHandleProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryZirconHandlePropertiesFUCHSIA<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkImportSemaphoreZirconHandleFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImportSemaphoreZirconHandleInfo, settings, "const VkImportSemaphoreZirconHandleInfoFUCHSIA*", "pImportSemaphoreZirconHandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImportSemaphoreZirconHandleInfoFUCHSIA<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetSemaphoreZirconHandleFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGetZirconHandleInfo, settings, "const VkSemaphoreGetZirconHandleInfoFUCHSIA*", "pGetZirconHandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreGetZirconHandleInfoFUCHSIA<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pZirconHandle, settings, "zx_handle_t*", "pZirconHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, zx_handle_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateBufferCollectionFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkBufferCollectionCreateInfoFUCHSIA*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCollectionCreateInfoFUCHSIA<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCollection, settings, "VkBufferCollectionFUCHSIA*", "pCollection", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCollectionFUCHSIA<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetBufferCollectionImageConstraintsFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBufferCollectionFUCHSIA<Format>(collection, settings, "VkBufferCollectionFUCHSIA", "collection", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pImageConstraintsInfo, settings, "const VkImageConstraintsInfoFUCHSIA*", "pImageConstraintsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageConstraintsInfoFUCHSIA<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetBufferCollectionBufferConstraintsFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBufferCollectionFUCHSIA<Format>(collection, settings, "VkBufferCollectionFUCHSIA", "collection", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBufferConstraintsInfo, settings, "const VkBufferConstraintsInfoFUCHSIA*", "pBufferConstraintsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferConstraintsInfoFUCHSIA<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyBufferCollectionFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBufferCollectionFUCHSIA<Format>(collection, settings, "VkBufferCollectionFUCHSIA", "collection", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetBufferCollectionPropertiesFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBufferCollectionFUCHSIA<Format>(collection, settings, "VkBufferCollectionFUCHSIA", "collection", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pProperties, settings, "VkBufferCollectionPropertiesFUCHSIA*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCollectionPropertiesFUCHSIA<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_FUCHSIA

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(ApiDumpInstance& dump_inst, VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkRenderPass<Format>(renderpass, settings, "VkRenderPass", "renderpass", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pMaxWorkgroupSize, 1, settings, "VkExtent2D*", "pMaxWorkgroupSize", "VkExtent2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSubpassShadingHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindInvocationMaskHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageView<Format>(imageView, settings, "VkImageView", "imageView", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(imageLayout, settings, "VkImageLayout", "imageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryRemoteAddressNV(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryGetRemoteAddressInfo, settings, "const VkMemoryGetRemoteAddressInfoNV*", "pMemoryGetRemoteAddressInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetRemoteAddressInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, VkRemoteAddressNV*>(pAddress, settings, "VkRemoteAddressNV*", "pAddress", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPipelinePropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPipelineInfo, settings, "const VkPipelineInfoKHR*", "pPipelineInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPipelineProperties, settings, "VkBaseOutStructure*", "pPipelineProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBaseOutStructure<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetPatchControlPointsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t patchControlPoints) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(patchControlPoints, settings, "uint32_t", "patchControlPoints", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetRasterizerDiscardEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(rasterizerDiscardEnable, settings, "VkBool32", "rasterizerDiscardEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthBiasEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(depthBiasEnable, settings, "VkBool32", "depthBiasEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetLogicOpEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkLogicOp<Format>(logicOp, settings, "VkLogicOp", "logicOp", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetPrimitiveRestartEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(primitiveRestartEnable, settings, "VkBool32", "primitiveRestartEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_SCREEN_QNX)

template <ApiDumpFormat Format>
void dump_params_vkCreateScreenSurfaceQNX(ApiDumpInstance& dump_inst, VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkScreenSurfaceCreateInfoQNX*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkScreenSurfaceCreateInfoQNX<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceScreenPresentationSupportQNX(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, struct _screen_window*>(window, settings, "struct _screen_window*", "window", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_SCREEN_QNX

template <ApiDumpFormat Format>
void dump_params_vkCmdSetColorWriteEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pColorWriteEnables, attachmentCount, settings, "const VkBool32*", "pColorWriteEnables", "const VkBool32", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkBool32>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawMultiEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pVertexInfo, drawCount, settings, "const VkMultiDrawInfoEXT*", "pVertexInfo", "const VkMultiDrawInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMultiDrawInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(instanceCount, settings, "uint32_t", "instanceCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstInstance, settings, "uint32_t", "firstInstance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawMultiIndexedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pIndexInfo, drawCount, settings, "const VkMultiDrawIndexedInfoEXT*", "pIndexInfo", "const VkMultiDrawIndexedInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMultiDrawIndexedInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(instanceCount, settings, "uint32_t", "instanceCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstInstance, settings, "uint32_t", "firstInstance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pVertexOffset, settings, "const int32_t*", "pVertexOffset", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const int32_t>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateMicromapEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkMicromapCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapCreateInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMicromap, settings, "VkMicromapEXT*", "pMicromap", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyMicromapEXT(ApiDumpInstance& dump_inst, VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkMicromapEXT<Format>(micromap, settings, "VkMicromapEXT", "micromap", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBuildMicromapsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pInfos, infoCount, settings, "const VkMicromapBuildInfoEXT*", "pInfos", "const VkMicromapBuildInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBuildMicromapsEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pInfos, infoCount, settings, "const VkMicromapBuildInfoEXT*", "pInfos", "const VkMicromapBuildInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyMicromapEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyMicromapInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyMicromapToMemoryEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyMicromapToMemoryInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapToMemoryInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyMemoryToMicromapEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyMemoryToMicromapInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToMicromapInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkWriteMicromapsPropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(micromapCount, settings, "uint32_t", "micromapCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pMicromaps, micromapCount, settings, "const VkMicromapEXT*", "pMicromaps", "const VkMicromapEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_VkQueryType<Format>(queryType, settings, "VkQueryType", "queryType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, size_t>(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, size_t>(stride, settings, "size_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyMicromapEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyMicromapInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyMicromapToMemoryEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyMicromapToMemoryInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapToMemoryInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyMemoryToMicromapEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyMemoryToMicromapInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToMicromapInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWriteMicromapsPropertiesEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(micromapCount, settings, "uint32_t", "micromapCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pMicromaps, micromapCount, settings, "const VkMicromapEXT*", "pMicromaps", "const VkMicromapEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_VkQueryType<Format>(queryType, settings, "VkQueryType", "queryType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceMicromapCompatibilityEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pVersionInfo, settings, "const VkMicromapVersionInfoEXT*", "pVersionInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapVersionInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCompatibility, settings, "VkAccelerationStructureCompatibilityKHR*", "pCompatibility", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCompatibilityKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetMicromapBuildSizesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkAccelerationStructureBuildTypeKHR<Format>(buildType, settings, "VkAccelerationStructureBuildTypeKHR", "buildType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBuildInfo, settings, "const VkMicromapBuildInfoEXT*", "pBuildInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSizeInfo, settings, "VkMicromapBuildSizesInfoEXT*", "pSizeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildSizesInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawClusterHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountX, settings, "uint32_t", "groupCountX", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountY, settings, "uint32_t", "groupCountY", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountZ, settings, "uint32_t", "groupCountZ", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawClusterIndirectHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetDeviceMemoryPriorityEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, float priority) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeviceMemory<Format>(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, float>(priority, settings, "float", "priority", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDispatchParametersARM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDispatchParametersARM* pDispatchParameters) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDispatchParameters, settings, "const VkDispatchParametersARM*", "pDispatchParameters", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDispatchParametersARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDescriptorSetLayoutHostMappingInfoVALVE(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBindingReference, settings, "const VkDescriptorSetBindingReferenceVALVE*", "pBindingReference", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetBindingReferenceVALVE<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pHostMapping, settings, "VkDescriptorSetLayoutHostMappingInfoVALVE*", "pHostMapping", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutHostMappingInfoVALVE<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDescriptorSetHostMappingVALVE(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSet descriptorSet, void** ppData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDescriptorSet<Format>(descriptorSet, settings, "VkDescriptorSet", "descriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, void**>(ppData, settings, "void**", "ppData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyMemoryIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(copyBufferAddress, settings, "VkDeviceAddress", "copyBufferAddress", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(copyCount, settings, "uint32_t", "copyCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyMemoryToImageIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(copyBufferAddress, settings, "VkDeviceAddress", "copyBufferAddress", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(copyCount, settings, "uint32_t", "copyCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImage<Format>(dstImage, settings, "VkImage", "dstImage", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pImageSubresources, copyCount, settings, "const VkImageSubresourceLayers*", "pImageSubresources", "const VkImageSubresourceLayers", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresourceLayers<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDecompressMemoryNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(decompressRegionCount, settings, "uint32_t", "decompressRegionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDecompressMemoryRegions, decompressRegionCount, settings, "const VkDecompressMemoryRegionNV*", "pDecompressMemoryRegions", "const VkDecompressMemoryRegionNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDecompressMemoryRegionNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDecompressMemoryIndirectCountNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(indirectCommandsAddress, settings, "VkDeviceAddress", "indirectCommandsAddress", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(indirectCommandsCountAddress, settings, "VkDeviceAddress", "indirectCommandsCountAddress", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPipelineIndirectMemoryRequirementsNV(ApiDumpInstance& dump_inst, VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkComputePipelineCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkComputePipelineCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdUpdatePipelineIndirectBufferNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineBindPoint<Format>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPipelineIndirectDeviceAddressNV(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkPipelineIndirectDeviceAddressInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineIndirectDeviceAddressInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_OHOS)

template <ApiDumpFormat Format>
void dump_params_vkGetNativeBufferPropertiesOHOS(ApiDumpInstance& dump_inst, VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const struct OH_NativeBuffer*>(buffer, settings, "const struct OH_NativeBuffer*", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pProperties, settings, "VkNativeBufferPropertiesOHOS*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkNativeBufferPropertiesOHOS<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryNativeBufferOHOS(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkMemoryGetNativeBufferInfoOHOS*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetNativeBufferInfoOHOS<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, struct OH_NativeBuffer**>(pBuffer, settings, "struct OH_NativeBuffer**", "pBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_OHOS

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthClampEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(depthClampEnable, settings, "VkBool32", "depthClampEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetPolygonModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPolygonMode<Format>(polygonMode, settings, "VkPolygonMode", "polygonMode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetRasterizationSamplesEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSampleCountFlagBits<Format>(rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetSampleMaskEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSampleCountFlagBits<Format>(samples, settings, "VkSampleCountFlagBits", "samples", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pSampleMask, (samples + 31) / 32, settings, "const VkSampleMask*", "pSampleMask", "const VkSampleMask", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkSampleMask>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetAlphaToCoverageEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(alphaToCoverageEnable, settings, "VkBool32", "alphaToCoverageEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetAlphaToOneEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(alphaToOneEnable, settings, "VkBool32", "alphaToOneEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetLogicOpEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(logicOpEnable, settings, "VkBool32", "logicOpEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetColorBlendEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstAttachment, settings, "uint32_t", "firstAttachment", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pColorBlendEnables, attachmentCount, settings, "const VkBool32*", "pColorBlendEnables", "const VkBool32", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkBool32>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetColorBlendEquationEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstAttachment, settings, "uint32_t", "firstAttachment", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pColorBlendEquations, attachmentCount, settings, "const VkColorBlendEquationEXT*", "pColorBlendEquations", "const VkColorBlendEquationEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkColorBlendEquationEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetColorWriteMaskEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstAttachment, settings, "uint32_t", "firstAttachment", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pColorWriteMasks, attachmentCount, settings, "const VkColorComponentFlags*", "pColorWriteMasks", "const VkColorComponentFlags", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkColorComponentFlags<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetTessellationDomainOriginEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkTessellationDomainOrigin<Format>(domainOrigin, settings, "VkTessellationDomainOrigin", "domainOrigin", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetRasterizationStreamEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t rasterizationStream) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(rasterizationStream, settings, "uint32_t", "rasterizationStream", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetConservativeRasterizationModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkConservativeRasterizationModeEXT<Format>(conservativeRasterizationMode, settings, "VkConservativeRasterizationModeEXT", "conservativeRasterizationMode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetExtraPrimitiveOverestimationSizeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, float>(extraPrimitiveOverestimationSize, settings, "float", "extraPrimitiveOverestimationSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthClipEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(depthClipEnable, settings, "VkBool32", "depthClipEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetSampleLocationsEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(sampleLocationsEnable, settings, "VkBool32", "sampleLocationsEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetColorBlendAdvancedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstAttachment, settings, "uint32_t", "firstAttachment", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pColorBlendAdvanced, attachmentCount, settings, "const VkColorBlendAdvancedEXT*", "pColorBlendAdvanced", "const VkColorBlendAdvancedEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkColorBlendAdvancedEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetProvokingVertexModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkProvokingVertexModeEXT<Format>(provokingVertexMode, settings, "VkProvokingVertexModeEXT", "provokingVertexMode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetLineRasterizationModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkLineRasterizationMode<Format>(lineRasterizationMode, settings, "VkLineRasterizationModeEXT", "lineRasterizationMode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetLineStippleEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(stippledLineEnable, settings, "VkBool32", "stippledLineEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthClipNegativeOneToOneEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(negativeOneToOne, settings, "VkBool32", "negativeOneToOne", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetViewportWScalingEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(viewportWScalingEnable, settings, "VkBool32", "viewportWScalingEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetViewportSwizzleNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstViewport, settings, "uint32_t", "firstViewport", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pViewportSwizzles, viewportCount, settings, "const VkViewportSwizzleNV*", "pViewportSwizzles", "const VkViewportSwizzleNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViewportSwizzleNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetCoverageToColorEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(coverageToColorEnable, settings, "VkBool32", "coverageToColorEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetCoverageToColorLocationNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(coverageToColorLocation, settings, "uint32_t", "coverageToColorLocation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetCoverageModulationModeNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCoverageModulationModeNV<Format>(coverageModulationMode, settings, "VkCoverageModulationModeNV", "coverageModulationMode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetCoverageModulationTableEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(coverageModulationTableEnable, settings, "VkBool32", "coverageModulationTableEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetCoverageModulationTableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(coverageModulationTableCount, settings, "uint32_t", "coverageModulationTableCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCoverageModulationTable, coverageModulationTableCount, settings, "const float*", "pCoverageModulationTable", "const float", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const float>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetShadingRateImageEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(shadingRateImageEnable, settings, "VkBool32", "shadingRateImageEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetRepresentativeFragmentTestEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(representativeFragmentTestEnable, settings, "VkBool32", "representativeFragmentTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetCoverageReductionModeNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkCoverageReductionModeNV<Format>(coverageReductionMode, settings, "VkCoverageReductionModeNV", "coverageReductionMode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateTensorARM(ApiDumpInstance& dump_inst, VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkTensorCreateInfoARM*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorCreateInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pTensor, settings, "VkTensorARM*", "pTensor", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyTensorARM(ApiDumpInstance& dump_inst, VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkTensorARM<Format>(tensor, settings, "VkTensorARM", "tensor", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateTensorViewARM(ApiDumpInstance& dump_inst, VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkTensorViewCreateInfoARM*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorViewCreateInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pView, settings, "VkTensorViewARM*", "pView", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorViewARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyTensorViewARM(ApiDumpInstance& dump_inst, VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkTensorViewARM<Format>(tensorView, settings, "VkTensorViewARM", "tensorView", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetTensorMemoryRequirementsARM(ApiDumpInstance& dump_inst, VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkTensorMemoryRequirementsInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorMemoryRequirementsInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBindTensorMemoryARM(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindInfos, bindInfoCount, settings, "const VkBindTensorMemoryInfoARM*", "pBindInfos", "const VkBindTensorMemoryInfoARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindTensorMemoryInfoARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceTensorMemoryRequirementsARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDeviceTensorMemoryRequirementsARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceTensorMemoryRequirementsARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyTensorARM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCopyTensorInfo, settings, "const VkCopyTensorInfoARM*", "pCopyTensorInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyTensorInfoARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceExternalTensorPropertiesARM(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalTensorInfo, settings, "const VkPhysicalDeviceExternalTensorInfoARM*", "pExternalTensorInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalTensorInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalTensorProperties, settings, "VkExternalTensorPropertiesARM*", "pExternalTensorProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalTensorPropertiesARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetTensorOpaqueCaptureDescriptorDataARM(ApiDumpInstance& dump_inst, VkDevice device, const VkTensorCaptureDescriptorDataInfoARM* pInfo, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkTensorCaptureDescriptorDataInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorCaptureDescriptorDataInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetTensorViewOpaqueCaptureDescriptorDataARM(ApiDumpInstance& dump_inst, VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkTensorViewCaptureDescriptorDataInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorViewCaptureDescriptorDataInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetShaderModuleIdentifierEXT(ApiDumpInstance& dump_inst, VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderModule<Format>(shaderModule, settings, "VkShaderModule", "shaderModule", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pIdentifier, settings, "VkShaderModuleIdentifierEXT*", "pIdentifier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleIdentifierEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetShaderModuleCreateInfoIdentifierEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkShaderModuleCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleCreateInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pIdentifier, settings, "VkShaderModuleIdentifierEXT*", "pIdentifier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleIdentifierEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pOpticalFlowImageFormatInfo, settings, "const VkOpticalFlowImageFormatInfoNV*", "pOpticalFlowImageFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowImageFormatInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFormatCount, settings, "uint32_t*", "pFormatCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pImageFormatProperties, *pFormatCount, settings, "VkOpticalFlowImageFormatPropertiesNV*", "pImageFormatProperties", "VkOpticalFlowImageFormatPropertiesNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowImageFormatPropertiesNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateOpticalFlowSessionNV(ApiDumpInstance& dump_inst, VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkOpticalFlowSessionCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowSessionCreateInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSession, settings, "VkOpticalFlowSessionNV*", "pSession", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowSessionNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyOpticalFlowSessionNV(ApiDumpInstance& dump_inst, VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkOpticalFlowSessionNV<Format>(session, settings, "VkOpticalFlowSessionNV", "session", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBindOpticalFlowSessionImageNV(ApiDumpInstance& dump_inst, VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkOpticalFlowSessionNV<Format>(session, settings, "VkOpticalFlowSessionNV", "session", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkOpticalFlowSessionBindingPointNV<Format>(bindingPoint, settings, "VkOpticalFlowSessionBindingPointNV", "bindingPoint", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageView<Format>(view, settings, "VkImageView", "view", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageLayout<Format>(layout, settings, "VkImageLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdOpticalFlowExecuteNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkOpticalFlowSessionNV<Format>(session, settings, "VkOpticalFlowSessionNV", "session", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExecuteInfo, settings, "const VkOpticalFlowExecuteInfoNV*", "pExecuteInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowExecuteInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkAntiLagUpdateAMD(ApiDumpInstance& dump_inst, VkDevice device, const VkAntiLagDataAMD* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pData, settings, "const VkAntiLagDataAMD*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAntiLagDataAMD<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateShadersEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCreateInfos, createInfoCount, settings, "const VkShaderCreateInfoEXT*", "pCreateInfos", "const VkShaderCreateInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderCreateInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pShaders, createInfoCount, settings, "VkShaderEXT*", "pShaders", "VkShaderEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyShaderEXT(ApiDumpInstance& dump_inst, VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderEXT<Format>(shader, settings, "VkShaderEXT", "shader", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetShaderBinaryDataEXT(ApiDumpInstance& dump_inst, VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderEXT<Format>(shader, settings, "VkShaderEXT", "shader", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDataSize, settings, "size_t*", "pDataSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, size_t>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBindShadersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stageCount, settings, "uint32_t", "stageCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pStages, stageCount, settings, "const VkShaderStageFlagBits*", "pStages", "const VkShaderStageFlagBits", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderStageFlagBits<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pShaders, stageCount, settings, "const VkShaderEXT*", "pShaders", "const VkShaderEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetDepthClampRangeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDepthClampModeEXT<Format>(depthClampMode, settings, "VkDepthClampModeEXT", "depthClampMode", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDepthClampRange, settings, "const VkDepthClampRangeEXT*", "pDepthClampRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDepthClampRangeEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetFramebufferTilePropertiesQCOM(ApiDumpInstance& dump_inst, VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkFramebuffer<Format>(framebuffer, settings, "VkFramebuffer", "framebuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertiesCount, settings, "uint32_t*", "pPropertiesCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertiesCount, settings, "VkTilePropertiesQCOM*", "pProperties", "VkTilePropertiesQCOM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTilePropertiesQCOM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDynamicRenderingTilePropertiesQCOM(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderingInfo, settings, "const VkRenderingInfo*", "pRenderingInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInfo<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pProperties, settings, "VkTilePropertiesQCOM*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTilePropertiesQCOM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceCooperativeVectorPropertiesNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkCooperativeVectorPropertiesNV*", "pProperties", "VkCooperativeVectorPropertiesNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeVectorPropertiesNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkConvertCooperativeVectorMatrixNV(ApiDumpInstance& dump_inst, VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkConvertCooperativeVectorMatrixInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkConvertCooperativeVectorMatrixInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdConvertCooperativeVectorMatrixNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pInfos, infoCount, settings, "const VkConvertCooperativeVectorMatrixInfoNV*", "pInfos", "const VkConvertCooperativeVectorMatrixInfoNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkConvertCooperativeVectorMatrixInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetLatencySleepModeNV(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSleepModeInfo, settings, "const VkLatencySleepModeInfoNV*", "pSleepModeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkLatencySleepModeInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkLatencySleepNV(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSleepInfo, settings, "const VkLatencySleepInfoNV*", "pSleepInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkLatencySleepInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkSetLatencyMarkerNV(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLatencyMarkerInfo, settings, "const VkSetLatencyMarkerInfoNV*", "pLatencyMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSetLatencyMarkerInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetLatencyTimingsNV(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkSwapchainKHR<Format>(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pLatencyMarkerInfo, settings, "VkGetLatencyMarkerInfoNV*", "pLatencyMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGetLatencyMarkerInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkQueueNotifyOutOfBandNV(ApiDumpInstance& dump_inst, VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkQueue<Format>(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueueTypeInfo, settings, "const VkOutOfBandQueueTypeInfoNV*", "pQueueTypeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOutOfBandQueueTypeInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDataGraphPipelinesARM(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineCache<Format>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCreateInfos, createInfoCount, settings, "const VkDataGraphPipelineCreateInfoARM*", "pCreateInfos", "const VkDataGraphPipelineCreateInfoARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineCreateInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateDataGraphPipelineSessionARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDataGraphPipelineSessionARM* pSession) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkDataGraphPipelineSessionCreateInfoARM*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionCreateInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSession, settings, "VkDataGraphPipelineSessionARM*", "pSession", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDataGraphPipelineSessionBindPointRequirementsARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDataGraphPipelineSessionBindPointRequirementsInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionBindPointRequirementsInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBindPointRequirementCount, settings, "uint32_t*", "pBindPointRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindPointRequirements, *pBindPointRequirementCount, settings, "VkDataGraphPipelineSessionBindPointRequirementARM*", "pBindPointRequirements", "VkDataGraphPipelineSessionBindPointRequirementARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionBindPointRequirementARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDataGraphPipelineSessionMemoryRequirementsARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDataGraphPipelineSessionMemoryRequirementsInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionMemoryRequirementsInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBindDataGraphPipelineSessionMemoryARM(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pBindInfos, bindInfoCount, settings, "const VkBindDataGraphPipelineSessionMemoryInfoARM*", "pBindInfos", "const VkBindDataGraphPipelineSessionMemoryInfoARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDataGraphPipelineSessionMemoryInfoARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyDataGraphPipelineSessionARM(ApiDumpInstance& dump_inst, VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDataGraphPipelineSessionARM<Format>(session, settings, "VkDataGraphPipelineSessionARM", "session", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDispatchDataGraphARM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDataGraphPipelineSessionARM<Format>(session, settings, "VkDataGraphPipelineSessionARM", "session", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkDataGraphPipelineDispatchInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineDispatchInfoARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDataGraphPipelineAvailablePropertiesARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t* pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPipelineInfo, settings, "const VkDataGraphPipelineInfoARM*", "pPipelineInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertiesCount, settings, "uint32_t*", "pPropertiesCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertiesCount, settings, "VkDataGraphPipelinePropertyARM*", "pProperties", "VkDataGraphPipelinePropertyARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelinePropertyARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDataGraphPipelinePropertiesARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPipelineInfo, settings, "const VkDataGraphPipelineInfoARM*", "pPipelineInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(propertiesCount, settings, "uint32_t", "propertiesCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, propertiesCount, settings, "VkDataGraphPipelinePropertyQueryResultARM*", "pProperties", "VkDataGraphPipelinePropertyQueryResultARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelinePropertyQueryResultARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueueFamilyDataGraphPropertyCount, settings, "uint32_t*", "pQueueFamilyDataGraphPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pQueueFamilyDataGraphProperties, *pQueueFamilyDataGraphPropertyCount, settings, "VkQueueFamilyDataGraphPropertiesARM*", "pQueueFamilyDataGraphProperties", "VkQueueFamilyDataGraphPropertiesARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyDataGraphPropertiesARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueueFamilyDataGraphProcessingEngineInfo, settings, "const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM*", "pQueueFamilyDataGraphProcessingEngineInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueueFamilyDataGraphProcessingEngineProperties, settings, "VkQueueFamilyDataGraphProcessingEnginePropertiesARM*", "pQueueFamilyDataGraphProcessingEngineProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyDataGraphProcessingEnginePropertiesARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, VkBaseOutStructure* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueueFamilyDataGraphProperties, settings, "const VkQueueFamilyDataGraphPropertiesARM*", "pQueueFamilyDataGraphProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyDataGraphPropertiesARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pProperties, settings, "VkBaseOutStructure*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBaseOutStructure<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetAttachmentFeedbackLoopEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkImageAspectFlags<Format>(aspectMask, settings, "VkImageAspectFlags", "aspectMask", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_SCREEN_QNX)

template <ApiDumpFormat Format>
void dump_params_vkGetScreenBufferPropertiesQNX(ApiDumpInstance& dump_inst, VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const struct _screen_buffer*>(buffer, settings, "const struct _screen_buffer*", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pProperties, settings, "VkScreenBufferPropertiesQNX*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkScreenBufferPropertiesQNX<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_SCREEN_QNX

template <ApiDumpFormat Format>
void dump_params_vkCmdBindTileMemoryQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pTileMemoryBindInfo, settings, "const VkTileMemoryBindInfoQCOM*", "pTileMemoryBindInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTileMemoryBindInfoQCOM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDecompressMemoryEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDecompressMemoryInfoEXT, settings, "const VkDecompressMemoryInfoEXT*", "pDecompressMemoryInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDecompressMemoryInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDecompressMemoryIndirectCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t maxDecompressionCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkMemoryDecompressionMethodFlagsEXT<Format>(decompressionMethod, settings, "VkMemoryDecompressionMethodFlagsEXT", "decompressionMethod", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(indirectCommandsAddress, settings, "VkDeviceAddress", "indirectCommandsAddress", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(indirectCommandsCountAddress, settings, "VkDeviceAddress", "indirectCommandsCountAddress", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(maxDecompressionCount, settings, "uint32_t", "maxDecompressionCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateExternalComputeQueueNV(ApiDumpInstance& dump_inst, VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkExternalComputeQueueCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalComputeQueueCreateInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pExternalQueue, settings, "VkExternalComputeQueueNV*", "pExternalQueue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalComputeQueueNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyExternalComputeQueueNV(ApiDumpInstance& dump_inst, VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkExternalComputeQueueNV<Format>(externalQueue, settings, "VkExternalComputeQueueNV", "externalQueue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetExternalComputeQueueDataNV(ApiDumpInstance& dump_inst, VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkExternalComputeQueueNV<Format>(externalQueue, settings, "VkExternalComputeQueueNV", "externalQueue", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(params, settings, "VkExternalComputeQueueDataParamsNV*", "params", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalComputeQueueDataParamsNV<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetClusterAccelerationStructureBuildSizesNV(ApiDumpInstance& dump_inst, VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkClusterAccelerationStructureInputInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClusterAccelerationStructureInputInfoNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSizeInfo, settings, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildSizesInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBuildClusterAccelerationStructureIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCommandInfos, settings, "const VkClusterAccelerationStructureCommandsInfoNV*", "pCommandInfos", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClusterAccelerationStructureCommandsInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPartitionedAccelerationStructuresBuildSizesNV(ApiDumpInstance& dump_inst, VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkPartitionedAccelerationStructureInstancesInputNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPartitionedAccelerationStructureInstancesInputNV<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSizeInfo, settings, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildSizesInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBuildPartitionedAccelerationStructuresNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBuildInfo, settings, "const VkBuildPartitionedAccelerationStructureInfoNV*", "pBuildInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuildPartitionedAccelerationStructureInfoNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetGeneratedCommandsMemoryRequirementsEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkGeneratedCommandsMemoryRequirementsInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsMemoryRequirementsInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdPreprocessGeneratedCommandsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoEXT*", "pGeneratedCommandsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_VkCommandBuffer<Format>(stateCommandBuffer, settings, "VkCommandBuffer", "stateCommandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdExecuteGeneratedCommandsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkBool32>(isPreprocessed, settings, "VkBool32", "isPreprocessed", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoEXT*", "pGeneratedCommandsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateIndirectCommandsLayoutEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkIndirectCommandsLayoutCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutCreateInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pIndirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT*", "pIndirectCommandsLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyIndirectCommandsLayoutEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkIndirectCommandsLayoutEXT<Format>(indirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateIndirectExecutionSetEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkIndirectExecutionSetCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectExecutionSetCreateInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pIndirectExecutionSet, settings, "VkIndirectExecutionSetEXT*", "pIndirectExecutionSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectExecutionSetEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyIndirectExecutionSetEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkIndirectExecutionSetEXT<Format>(indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkUpdateIndirectExecutionSetPipelineEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkIndirectExecutionSetEXT<Format>(indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(executionSetWriteCount, settings, "uint32_t", "executionSetWriteCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pExecutionSetWrites, executionSetWriteCount, settings, "const VkWriteIndirectExecutionSetPipelineEXT*", "pExecutionSetWrites", "const VkWriteIndirectExecutionSetPipelineEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteIndirectExecutionSetPipelineEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkUpdateIndirectExecutionSetShaderEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkIndirectExecutionSetEXT<Format>(indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(executionSetWriteCount, settings, "uint32_t", "executionSetWriteCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pExecutionSetWrites, executionSetWriteCount, settings, "const VkWriteIndirectExecutionSetShaderEXT*", "pExecutionSetWrites", "const VkWriteIndirectExecutionSetShaderEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteIndirectExecutionSetShaderEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_OHOS)

template <ApiDumpFormat Format>
void dump_params_vkCreateSurfaceOHOS(ApiDumpInstance& dump_inst, VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkSurfaceCreateInfoOHOS*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCreateInfoOHOS<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_OHOS

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pProperties, *pPropertyCount, settings, "VkCooperativeMatrixFlexibleDimensionsPropertiesNV*", "pProperties", "VkCooperativeMatrixFlexibleDimensionsPropertiesNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeMatrixFlexibleDimensionsPropertiesNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_METAL_EXT)

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryMetalHandleEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pGetMetalHandleInfo, settings, "const VkMemoryGetMetalHandleInfoEXT*", "pGetMetalHandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetMetalHandleInfoEXT<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void**>(pHandle, settings, "void**", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetMemoryMetalHandlePropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkExternalMemoryHandleTypeFlagBits<Format>(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, const void*>(pHandle, settings, "const void*", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMemoryMetalHandleProperties, settings, "VkMemoryMetalHandlePropertiesEXT*", "pMemoryMetalHandleProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryMetalHandlePropertiesEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_METAL_EXT

template <ApiDumpFormat Format>
void dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCounterCount, settings, "uint32_t*", "pCounterCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCounters, *pCounterCount, settings, "VkPerformanceCounterARM*", "pCounters", "VkPerformanceCounterARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCounterDescriptions, *pCounterCount, settings, "VkPerformanceCounterDescriptionARM*", "pCounterDescriptions", "VkPerformanceCounterDescriptionARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterDescriptionARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pDescriptionCount, VkShaderInstrumentationMetricDescriptionARM* pDescriptions) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pDescriptionCount, settings, "uint32_t*", "pDescriptionCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pDescriptions, *pDescriptionCount, settings, "VkShaderInstrumentationMetricDescriptionARM*", "pDescriptions", "VkShaderInstrumentationMetricDescriptionARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderInstrumentationMetricDescriptionARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateShaderInstrumentationARM(ApiDumpInstance& dump_inst, VkDevice device, const VkShaderInstrumentationCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderInstrumentationARM* pInstrumentation) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkShaderInstrumentationCreateInfoARM*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderInstrumentationCreateInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInstrumentation, settings, "VkShaderInstrumentationARM*", "pInstrumentation", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderInstrumentationARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyShaderInstrumentationARM(ApiDumpInstance& dump_inst, VkDevice device, VkShaderInstrumentationARM instrumentation, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderInstrumentationARM<Format>(instrumentation, settings, "VkShaderInstrumentationARM", "instrumentation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginShaderInstrumentationARM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkShaderInstrumentationARM instrumentation) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderInstrumentationARM<Format>(instrumentation, settings, "VkShaderInstrumentationARM", "instrumentation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndShaderInstrumentationARM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetShaderInstrumentationValuesARM(ApiDumpInstance& dump_inst, VkDevice device, VkShaderInstrumentationARM instrumentation, uint32_t* pMetricBlockCount, void* pMetricValues, VkShaderInstrumentationValuesFlagsARM flags) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderInstrumentationARM<Format>(instrumentation, settings, "VkShaderInstrumentationARM", "instrumentation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMetricBlockCount, settings, "uint32_t*", "pMetricBlockCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pMetricValues, settings, "void*", "pMetricValues", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderInstrumentationValuesFlagsARM<Format>(flags, settings, "VkShaderInstrumentationValuesFlagsARM", "flags", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkClearShaderInstrumentationMetricsARM(ApiDumpInstance& dump_inst, VkDevice device, VkShaderInstrumentationARM instrumentation) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderInstrumentationARM<Format>(instrumentation, settings, "VkShaderInstrumentationARM", "instrumentation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdEndRendering2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRenderingEndInfo, settings, "const VkRenderingEndInfoKHR*", "pRenderingEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingEndInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBeginCustomResolveEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBeginCustomResolveInfo, settings, "const VkBeginCustomResolveInfoEXT*", "pBeginCustomResolveInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBeginCustomResolveInfoEXT<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pQueueFamilyDataGraphProperties, settings, "const VkQueueFamilyDataGraphPropertiesARM*", "pQueueFamilyDataGraphProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyDataGraphPropertiesARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pOpticalFlowImageFormatInfo, settings, "const VkDataGraphOpticalFlowImageFormatInfoARM*", "pOpticalFlowImageFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphOpticalFlowImageFormatInfoARM<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pFormatCount, settings, "uint32_t*", "pFormatCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pImageFormatProperties, *pFormatCount, settings, "VkDataGraphOpticalFlowImageFormatPropertiesARM*", "pImageFormatProperties", "VkDataGraphOpticalFlowImageFormatPropertiesARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphOpticalFlowImageFormatPropertiesARM<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetComputeOccupancyPriorityNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkComputeOccupancyPriorityParametersNV* pParameters) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pParameters, settings, "const VkComputeOccupancyPriorityParametersNV*", "pParameters", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkComputeOccupancyPriorityParametersNV<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#if defined(VK_USE_PLATFORM_UBM_SEC)

template <ApiDumpFormat Format>
void dump_params_vkCreateUbmSurfaceSEC(ApiDumpInstance& dump_inst, VkInstance instance, const VkUbmSurfaceCreateInfoSEC* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkInstance<Format>(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkUbmSurfaceCreateInfoSEC*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkUbmSurfaceCreateInfoSEC<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetPhysicalDeviceUbmPresentationSupportSEC(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct ubm_device* device) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkPhysicalDevice<Format>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, struct ubm_device*>(device, settings, "struct ubm_device*", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}
#endif  // VK_USE_PLATFORM_UBM_SEC

template <ApiDumpFormat Format>
void dump_params_vkCmdSetPrimitiveRestartIndexEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t primitiveRestartIndex) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(primitiveRestartIndex, settings, "uint32_t", "primitiveRestartIndex", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCreateInfo, settings, "const VkAccelerationStructureCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAccelerationStructure, settings, "VkAccelerationStructureKHR*", "pAccelerationStructure", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkDestroyAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkAccelerationStructureKHR<Format>(accelerationStructure, settings, "VkAccelerationStructureKHR", "accelerationStructure", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBuildAccelerationStructuresKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pInfos, infoCount, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pInfos", "const VkAccelerationStructureBuildGeometryInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_double_pointer_array<Format>(ppBuildRangeInfos, infoCount, settings, "const VkAccelerationStructureBuildRangeInfoKHR* const*", "ppBuildRangeInfos", "const VkAccelerationStructureBuildRangeInfoKHR*", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildRangeInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdBuildAccelerationStructuresIndirectKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pInfos, infoCount, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pInfos", "const VkAccelerationStructureBuildGeometryInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pIndirectDeviceAddresses, infoCount, settings, "const VkDeviceAddress*", "pIndirectDeviceAddresses", "const VkDeviceAddress", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const VkDeviceAddress>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pIndirectStrides, infoCount, settings, "const uint32_t*", "pIndirectStrides", "const uint32_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(ppMaxPrimitiveCounts, infoCount, settings, "const uint32_t* const*", "ppMaxPrimitiveCounts", "const uint32_t*", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const uint32_t*>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkBuildAccelerationStructuresKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pInfos, infoCount, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pInfos", "const VkAccelerationStructureBuildGeometryInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_double_pointer_array<Format>(ppBuildRangeInfos, infoCount, settings, "const VkAccelerationStructureBuildRangeInfoKHR* const*", "ppBuildRangeInfos", "const VkAccelerationStructureBuildRangeInfoKHR*", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildRangeInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyAccelerationStructureInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyAccelerationStructureToMemoryKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyAccelerationStructureToMemoryInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureToMemoryInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCopyMemoryToAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyMemoryToAccelerationStructureInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToAccelerationStructureInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pAccelerationStructures, accelerationStructureCount, settings, "const VkAccelerationStructureKHR*", "pAccelerationStructures", "const VkAccelerationStructureKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_VkQueryType<Format>(queryType, settings, "VkQueryType", "queryType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, size_t>(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, size_t>(stride, settings, "size_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyAccelerationStructureInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyAccelerationStructureToMemoryKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyAccelerationStructureToMemoryInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureToMemoryInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdCopyMemoryToAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkCopyMemoryToAccelerationStructureInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToAccelerationStructureInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetAccelerationStructureDeviceAddressKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pInfo, settings, "const VkAccelerationStructureDeviceAddressInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureDeviceAddressInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pAccelerationStructures, accelerationStructureCount, settings, "const VkAccelerationStructureKHR*", "pAccelerationStructures", "const VkAccelerationStructureKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_VkQueryType<Format>(queryType, settings, "VkQueryType", "queryType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkQueryPool<Format>(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetDeviceAccelerationStructureCompatibilityKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pVersionInfo, settings, "const VkAccelerationStructureVersionInfoKHR*", "pVersionInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureVersionInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCompatibility, settings, "VkAccelerationStructureCompatibilityKHR*", "pCompatibility", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCompatibilityKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetAccelerationStructureBuildSizesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkAccelerationStructureBuildTypeKHR<Format>(buildType, settings, "VkAccelerationStructureBuildTypeKHR", "buildType", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pBuildInfo, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pBuildInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pMaxPrimitiveCounts, pBuildInfo->geometryCount, settings, "const uint32_t*", "pMaxPrimitiveCounts", "const uint32_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type<Format, const uint32_t>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pSizeInfo, settings, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildSizesInfoKHR<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdTraceRaysKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRaygenShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pRaygenShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMissShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pMissShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pHitShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pHitShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCallableShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pCallableShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(width, settings, "uint32_t", "width", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(height, settings, "uint32_t", "height", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(depth, settings, "uint32_t", "depth", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCreateRayTracingPipelinesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkDeferredOperationKHR<Format>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipelineCache<Format>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pCreateInfos, createInfoCount, settings, "const VkRayTracingPipelineCreateInfoKHR*", "pCreateInfos", "const VkRayTracingPipelineCreateInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRayTracingPipelineCreateInfoKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer_array<Format>(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline<Format>);
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(firstGroup, settings, "uint32_t", "firstGroup", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCount, settings, "uint32_t", "groupCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, size_t>(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, void*>(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdTraceRaysIndirectKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pRaygenShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pRaygenShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pMissShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pMissShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pHitShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pHitShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_pointer<Format>(pCallableShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pCallableShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR<Format>);
        dump_separate_members<Format>(settings);
        dump_type_hex<Format, VkDeviceAddress>(indirectDeviceAddress, settings, "VkDeviceAddress", "indirectDeviceAddress", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkGetRayTracingShaderGroupStackSizeKHR(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkDevice<Format>(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkPipeline<Format>(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(group, settings, "uint32_t", "group", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkShaderGroupShaderKHR<Format>(groupShader, settings, "VkShaderGroupShaderKHR", "groupShader", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdSetRayTracingPipelineStackSizeKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(pipelineStackSize, settings, "uint32_t", "pipelineStackSize", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawMeshTasksEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountX, settings, "uint32_t", "groupCountX", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountY, settings, "uint32_t", "groupCountY", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(groupCountZ, settings, "uint32_t", "groupCountZ", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawMeshTasksIndirectEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

template <ApiDumpFormat Format>
void dump_params_vkCmdDrawMeshTasksIndirectCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
    const ApiDumpSettings& settings(dump_inst.settings());
    if (settings.showParams()) {
        dump_pre_params_formatting<Format>(settings);
        dump_VkCommandBuffer<Format>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_VkBuffer<Format>(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_separate_members<Format>(settings);
        dump_type<Format, uint32_t>(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1));
        dump_post_params_formatting<Format>(settings);
        flush(settings);
    }
}

//========================== Type Implementations =========================//

template <ApiDumpFormat Format>
void dump_return_value_VkDeviceAddress(const VkDeviceAddress& address, const ApiDumpSettings& settings) {
    dump_value_hex<Format>(settings, static_cast<uint64_t>(address));
}
